@arp-protocol/cli 0.0.0-stage → 0.0.3

package/dist/chunks/env-n5ac8d1z.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import"./cli-g5zvr10v.js";
+
+// src/install/env.ts
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+function which(command) {
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (dir.length === 0)
+      continue;
+    const candidate = join(dir, command);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function processEnv(dist, version) {
+  return {
+    home: homedir(),
+    arpHome: process.env["ARP_HOME"]?.trim() || join(homedir(), ".arp"),
+    cwd: process.cwd(),
+    which,
+    run: (argv, stdin, timeoutMs = 15000) => {
+      const [command, ...args] = argv;
+      const result = spawnSync(command ?? "", args, {
+        input: stdin,
+        encoding: "utf8",
+        timeout: timeoutMs
+      });
+      return { code: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+    },
+    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    ask: async (question) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        const answer = await rl.question(`${question} [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+      } finally {
+        rl.close();
+      }
+    },
+    out: (line) => process.stdout.write(`${line}
+`),
+    err: (line) => process.stderr.write(`${line}
+`),
+    now: () => new Date,
+    node: process.execPath,
+    dist,
+    version
+  };
+}
+export {
+  processEnv
+};

package/dist/chunks/index-jrs2shcc.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  DEFAULT_SERVE_MAX_BODY_BYTES,
+  KeyFileError,
+  MovedStateError,
+  appendJsonLine,
+  arpHome,
+  bigintSafe,
+  bufferedCopy,
+  jsonResponse,
+  linesOf,
+  loadOrCreateKeyFile,
+  lockFile,
+  loopbackHosts,
+  readJsonLines,
+  readKeyFile,
+  redactUrls,
+  refuseForeignRequest,
+  refuseMovedState,
+  serveFetch,
+  stateFile
+} from "./cli-n4qagybd.js";
+import {
+  ERC8004_REGISTRY
+} from "./cli-fbwpcfvp.js";
+import"./cli-mhzh9z8k.js";
+import"./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+export {
+  stateFile,
+  serveFetch,
+  refuseMovedState,
+  refuseForeignRequest,
+  redactUrls,
+  readKeyFile,
+  readJsonLines,
+  loopbackHosts,
+  lockFile,
+  loadOrCreateKeyFile,
+  linesOf,
+  jsonResponse,
+  bufferedCopy,
+  bigintSafe,
+  arpHome,
+  appendJsonLine,
+  MovedStateError,
+  KeyFileError,
+  ERC8004_REGISTRY as ERC8004_REGISTRY_REF,
+  DEFAULT_SERVE_MAX_BODY_BYTES,
+  DEFAULT_REQUEST_TIMEOUT_MS
+};

package/dist/chunks/line-691gbaha.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import {
+  agentFor,
+  chainId,
+  domainWalk,
+  domainWords,
+  loopConfig,
+  sponsorApproval,
+  writeLine
+} from "./cli-10wacn76.js";
+import"./cli-00qp1sj2.js";
+import"./cli-n4qagybd.js";
+import {
+  USAGE_REASONS,
+  X402_DEFAULT_NETWORKS,
+  chainIdOfNetwork,
+  isCategoryIn,
+  isExactEndpointUrl,
+  isTransactionAbsent,
+  isUsageOutcome,
+  isUsageReason,
+  needShapeProblem,
+  normaliseCategoryLabel,
+  readDomainTree,
+  resolveDomain,
+  transfersIn,
+  x402NetworksFrom,
+  x402Reading
+} from "./cli-wev0jgf7.js";
+import"./cli-0gsbnq5w.js";
+import"./cli-fbwpcfvp.js";
+import"./cli-mhzh9z8k.js";
+import"./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+
+// ../mcp/src/line.ts
+function lineNetworks(env = process.env) {
+  return x402NetworksFrom(X402_DEFAULT_NETWORKS, env);
+}
+function lineFromArgs(args, env = process.env) {
+  if (args.parent === undefined !== (args.why === undefined))
+    return new Error("--parent and --why go together");
+  if (args.paymentTx === undefined !== (args.network === undefined))
+    return new Error("--payment-tx and --network go together");
+  if (args.network !== undefined && chainIdOfNetwork(args.network) === null) {
+    return new Error("--network is a CAIP-2 EVM network, such as eip155:8453 for Base");
+  }
+  if (args.network !== undefined) {
+    let networks;
+    try {
+      networks = lineNetworks(env);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(String(error));
+    }
+    if (!networks.has(args.network))
+      return new Error(`--network must be one of ${[...networks.keys()].join(", ")}`);
+  }
+  if (args.paymentTx !== undefined && !/^0x[0-9a-fA-F]{64}$/.test(args.paymentTx))
+    return new Error("--payment-tx is a 32-byte transaction hash");
+  if (args.paymentTx !== undefined && !isExactEndpointUrl(args.toolUrl)) {
+    return new Error("with --payment-tx, --tool is the exact URL you paid, scheme included, as you called it");
+  }
+  if (args.parent !== undefined && args.domain === undefined)
+    return new Error("--parent and --why add a --domain");
+  if (args.why !== undefined && args.why.trim() === "")
+    return new Error("--why says why no category fits");
+  if (!isUsageOutcome(args.outcome))
+    return new Error("--outcome must be worked or failed");
+  if (args.reason !== undefined && !isUsageReason(args.reason)) {
+    return new Error(`--reason must be one of ${USAGE_REASONS.join(", ")}`);
+  }
+  if (args.reason !== undefined && args.outcome !== "failed")
+    return new Error("a reason only follows --outcome failed");
+  if (args.needs !== undefined && args.outcome !== "failed")
+    return new Error("--needs follows --outcome failed; a worked line takes --with");
+  if (args.with !== undefined && args.outcome !== "worked")
+    return new Error("--with follows --outcome worked; a failure takes --needs");
+  const need = args.needs ?? args.with;
+  if (need !== undefined) {
+    const problem = needShapeProblem({ need, outcome: args.outcome, reason: args.reason ?? "" });
+    if (problem !== null)
+      return new Error(problem);
+    if (args.paymentTx !== undefined)
+      return new Error("--needs and --with name a skill's word; a paid endpoint has no SKILL.md");
+  }
+  return {
+    toolUrl: args.toolUrl,
+    outcome: args.outcome,
+    ...args.domain === undefined ? {} : { domain: args.domain },
+    ...args.reason === undefined ? {} : { reason: args.reason },
+    ...args.parent === undefined || args.why === undefined ? {} : { newDomain: { parent: args.parent, why: args.why.trim() } },
+    ...args.paymentTx === undefined || args.network === undefined ? {} : { payment: { network: args.network, txHash: args.paymentTx.toLowerCase() } },
+    ...need === undefined ? {} : { need }
+  };
+}
+async function readLinePayment(input, reading) {
+  if (input.payment === undefined)
+    return null;
+  const { network, txHash } = input.payment;
+  const assets = reading.policy.get(network)?.assets ?? [];
+  const reads = reading.readsFor(network);
+  let receipt;
+  try {
+    receipt = await reads.getTransactionReceipt({ hash: txHash });
+  } catch (error) {
+    if (isTransactionAbsent(error))
+      throw new Error(`transaction ${txHash} not found on ${network}`);
+    throw new Error(`${network} could not be read: ${error instanceof Error ? error.message.split(`
+`)[0] : String(error)}`);
+  }
+  if (receipt.status !== "success")
+    throw new Error(`the payment ${txHash} reverted on ${network}`);
+  const transfers = transfersIn(receipt.logs, assets);
+  if (transfers.length === 0)
+    throw new Error(`${txHash} on ${network} moves no accepted asset (${assets.join(", ")})`);
+  return { network, txHash, transfers: transfers.map((transfer) => ({ ...transfer, amount: transfer.amount.toString() })) };
+}
+async function writeLineChecked(steps, input) {
+  let line = input;
+  let payment = null;
+  if (input.payment !== undefined) {
+    if (!isExactEndpointUrl(input.toolUrl))
+      throw new Error(`${input.toolUrl} is not the exact http(s) URL that was paid`);
+    if (steps.payments === undefined)
+      throw new Error("this build reads no payment network");
+    payment = await readLinePayment(input, steps.payments);
+  }
+  if (input.domain !== undefined) {
+    const domain = normaliseCategoryLabel(input.domain);
+    const resolved = await steps.isCategory(domain) ? null : await steps.resolve?.(domain);
+    if (resolved === null || resolved?.status === "node") {
+      const { newDomain: _unused, ...rest } = input;
+      line = { ...rest, domain: resolved?.status === "node" ? resolved.label : domain };
+    } else if (input.newDomain === undefined) {
+      const closest = resolved?.status === "unknown" && resolved.suggestions.length > 0 ? ` Closest: ${resolved.suggestions.join(", ")}.` : "";
+      throw new Error(`"${input.domain}" is not a category under tool.${closest} Pick one, or add it with --parent <category> --why <reason>`);
+    } else {
+      const parent = normaliseCategoryLabel(input.newDomain.parent);
+      if (!await steps.isCategory(parent))
+        throw new Error(`--parent "${input.newDomain.parent}" is not a category under tool`);
+      line = { ...input, domain, newDomain: { parent, why: input.newDomain.why } };
+    }
+  }
+  await sponsorApproval(steps.config);
+  const written = await (steps.write ?? writeLine)(steps.config, steps.agent(), line);
+  return payment === null ? written : { ...written, payment };
+}
+async function writeLineHere(input) {
+  if (chainId !== 13579)
+    throw new Error("a line is written on testnet 13579 only for now");
+  return writeLineChecked({
+    config: loopConfig(),
+    isCategory: async (label) => isCategoryIn(await readDomainTree(domainWalk()))(label),
+    resolve: async (word) => resolveDomain(word, domainWords(await readDomainTree(domainWalk()))),
+    agent: agentFor,
+    payments: x402Reading(lineNetworks(), process.env)
+  }, input);
+}
+export {
+  writeLineHere,
+  writeLineChecked,
+  readLinePayment,
+  lineNetworks,
+  lineFromArgs
+};

package/dist/chunks/node-init-rcepfyeh.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import {
+  resolveNodeKey
+} from "./cli-64fx73kx.js";
+import"./cli-n4qagybd.js";
+import {
+  asEndpointBinding,
+  endpointBindingDocument,
+  normaliseEndpoint,
+  parseAgentRegistry,
+  validateHandshakeRequest
+} from "./cli-wev0jgf7.js";
+import"./cli-0gsbnq5w.js";
+import"./cli-fbwpcfvp.js";
+import {
+  isHex
+} from "./cli-mhzh9z8k.js";
+import"./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+
+// src/node-init.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// ../node/src/register.ts
+async function post(fetchLike, url, body) {
+  const response = await fetchLike(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await response.json();
+  } catch {
+    parsed = null;
+  }
+  return { status: response.status, ok: response.ok, body: parsed };
+}
+function refusal(status, body) {
+  if (typeof body === "object" && body !== null) {
+    const { error, reason } = body;
+    if (typeof error === "string")
+      return typeof reason === "string" ? `${error}: ${reason}` : error;
+  }
+  return `HTTP ${status}`;
+}
+function isChallenge(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return typeof record["nonce"] === "string" && typeof record["message"] === "string" && typeof record["owner"] === "string" && typeof record["nodeAddress"] === "string";
+}
+async function register(options) {
+  const fetchLike = options.fetch ?? fetch;
+  const base = options.directoryUrl.replace(/\/$/, "");
+  const request = {
+    ...options.agent,
+    nodePublicKey: options.node.publicKey,
+    endpoint: options.endpoint
+  };
+  const valid = validateHandshakeRequest(request);
+  if (!valid.ok) {
+    return {
+      ok: false,
+      step: "request",
+      reason: valid.error.code === "malformed" ? valid.error.reason : valid.error.code
+    };
+  }
+  let answer;
+  try {
+    answer = await post(fetchLike, `${base}/challenge`, request);
+  } catch (error) {
+    return {
+      ok: false,
+      step: "challenge",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!answer.ok)
+    return { ok: false, step: "challenge", reason: refusal(answer.status, answer.body) };
+  if (!isChallenge(answer.body))
+    return { ok: false, step: "challenge", reason: "not a challenge" };
+  const challenge = answer.body;
+  if (challenge.nodeAddress.toLowerCase() !== options.node.address.toLowerCase()) {
+    return { ok: false, step: "challenge", reason: "the challenge names another node key" };
+  }
+  let ownerSignature;
+  try {
+    ownerSignature = await options.signAsOwner(challenge);
+  } catch (error) {
+    return {
+      ok: false,
+      step: "owner",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!isHex(ownerSignature))
+    return { ok: false, step: "owner", reason: "the signature is not hex" };
+  const nodeSignature = await options.node.signMessage({ message: challenge.message });
+  let done;
+  try {
+    done = await post(fetchLike, `${base}/complete`, {
+      nonce: challenge.nonce,
+      ownerSignature,
+      nodeSignature
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      step: "complete",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!done.ok)
+    return { ok: false, step: "complete", reason: refusal(done.status, done.body) };
+  const binding = asEndpointBinding(done.body);
+  if (binding === null || binding.message !== challenge.message) {
+    return { ok: false, step: "complete", reason: "the directory did not return this binding" };
+  }
+  return { ok: true, binding, challenge };
+}
+
+// src/node-init.ts
+var NODE_INIT_EXIT = { ok: 0, usage: 2, refused: 3, failed: 6 };
+var VALUE_FLAGS = {
+  "--agent-registry": "agentRegistry",
+  "--agent-id": "agentId",
+  "--endpoint": "endpoint",
+  "--directory": "directory"
+};
+function parseNodeInitFlags(args) {
+  const flags = {
+    agentRegistry: null,
+    agentId: null,
+    endpoint: null,
+    directory: null,
+    noInput: false
+  };
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i] ?? "";
+    if (arg === "--node")
+      continue;
+    if (arg === "--no-input") {
+      flags.noInput = true;
+      continue;
+    }
+    const [name, inline] = arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, null];
+    if (name in VALUE_FLAGS) {
+      const value = inline ?? args[i + 1];
+      if (inline === null)
+        i += 1;
+      if (value === undefined || value.length === 0 || value.startsWith("--")) {
+        return new Error(`${name} needs a value`);
+      }
+      flags[VALUE_FLAGS[name]] = value;
+      continue;
+    }
+    return new Error(`unknown option '${arg}' for init --node`);
+  }
+  return flags;
+}
+function writePrivate(path, text) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, text, { mode: 384 });
+}
+async function nodeInit(flags, io) {
+  const agentRegistry = flags.agentRegistry ?? io.env["AGENT_REGISTRY"] ?? null;
+  const agentId = flags.agentId ?? io.env["AGENT_ID"] ?? null;
+  const endpointRaw = flags.endpoint ?? io.env["ARP_NODE_PUBLIC_URL"] ?? null;
+  const directory = flags.directory ?? io.env["ARP_DIRECTORY_URL"] ?? null;
+  const missing = [];
+  if (agentRegistry === null)
+    missing.push("--agent-registry (or AGENT_REGISTRY)");
+  if (agentId === null)
+    missing.push("--agent-id (or AGENT_ID)");
+  if (endpointRaw === null)
+    missing.push("--endpoint (or ARP_NODE_PUBLIC_URL)");
+  if (directory === null)
+    missing.push("--directory (or ARP_DIRECTORY_URL)");
+  if (missing.length > 0 || agentRegistry === null || agentId === null || endpointRaw === null || directory === null) {
+    io.err(`arp init --node: missing ${missing.join(", ")}`);
+    return NODE_INIT_EXIT.usage;
+  }
+  if (parseAgentRegistry(agentRegistry) === null || !/^(0|[1-9][0-9]*)$/.test(agentId)) {
+    io.err("arp init --node: the agent is eip155:<chainId>:<registry> plus a decimal token id");
+    return NODE_INIT_EXIT.usage;
+  }
+  const endpoint = normaliseEndpoint(endpointRaw);
+  if (endpoint === null) {
+    io.err(`arp init --node: the endpoint must be the tunnel's https URL, got ${endpointRaw}`);
+    return NODE_INIT_EXIT.usage;
+  }
+  if (flags.noInput || !io.interactive) {
+    io.err("arp init --node: the owner signs the handshake in their wallet, which needs a terminal");
+    return NODE_INIT_EXIT.refused;
+  }
+  let key;
+  try {
+    key = resolveNodeKey(io.env, { home: io.home });
+  } catch (error) {
+    io.err(`arp init --node: ${error instanceof Error ? error.message : String(error)}`);
+    return NODE_INIT_EXIT.failed;
+  }
+  io.err(`node key   ${key.account.address}  (${key.source === "env" ? "AGENT_PRIVATE_KEY" : key.path})`);
+  const messagePath = join(io.home, ".arp", "handshake-message.txt");
+  const result = await register({
+    directoryUrl: directory,
+    agent: { agentRegistry, agentId },
+    endpoint,
+    node: key.account,
+    ...io.fetch === undefined ? {} : { fetch: io.fetch },
+    async signAsOwner(challenge) {
+      writePrivate(messagePath, challenge.message);
+      io.err("");
+      io.err(`Sign this message as ${challenge.owner}, the token's owner, before ${challenge.expiresAt}:`);
+      io.err("");
+      for (const line of challenge.message.split(`
+`))
+        io.err(`  ${line}`);
+      io.err("");
+      io.err(`It is also in ${messagePath}. With Foundry, for example:`);
+      io.err(`  cast wallet sign --interactive "$(cat ${messagePath})"`);
+      io.err("");
+      const answer = (await io.readLine("owner signature (0x…): ")).trim();
+      if (!isHex(answer) || answer.length < 132)
+        throw new Error("that is not a signature");
+      return answer;
+    }
+  });
+  if (!result.ok) {
+    io.err(`arp init --node: ${result.step} refused: ${result.reason}`);
+    return NODE_INIT_EXIT.failed;
+  }
+  const bindingPath = join(io.home, ".arp", "node-binding.json");
+  const documentPath = join(io.home, ".arp", "node-binding.document.json");
+  writePrivate(bindingPath, `${JSON.stringify(result.binding, null, 2)}
+`);
+  writePrivate(documentPath, endpointBindingDocument(result.binding));
+  io.out(`bound      node ${result.binding.nodeAddress} to agent ${agentId} of ${agentRegistry}`);
+  io.out(`endpoint   ${result.binding.endpoint}`);
+  io.out(`saved      ${bindingPath}`);
+  io.out(`document   ${documentPath}`);
+  io.out("");
+  io.out("Next: pin the document to IPFS, then write the binding on Intuition testnet with");
+  io.out("`prepareEndpointBinding`. This command signs no transaction.");
+  io.out("A transfer of the token voids the binding until you run this again.");
+  return NODE_INIT_EXIT.ok;
+}
+export {
+  parseNodeInitFlags,
+  nodeInit,
+  NODE_INIT_EXIT
+};