@arp-protocol/cli 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,69 @@
-# Temporary Holding Version
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Wieedze/ARP/main/docs/design/brand/arp-lockup-dark.svg" />
+  <img src="https://raw.githubusercontent.com/Wieedze/ARP/main/docs/design/brand/arp-lockup-light.svg" height="40" alt="ARP" />
+</picture>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @arp-protocol/cli
+
+ARP's agent-side programs in one binary. Node 22 or later.
+
+```
+arp mcp            the MCP server, over stdio (how an MCP client launches it). --http for 127.0.0.1
+arp hook           the runtime hook: one payload on stdin, one line in .arp/session.jsonl
+arp node           the hire endpoint. Opt-in: 127.0.0.1, reached through a tunnel you rent
+arp init --node    bind the node to your ERC-8004 agent: the token's owner signs once
+```
+
+All three run on your machine, and none of them signs a transaction.
+
+- **What each one reads, writes and connects to** is in
+  [`docs/22_RUNNING_THE_NODE.md`](https://github.com/Wieedze/ARP/blob/main/docs/22_RUNNING_THE_NODE.md).
+- **What the hook records**, and what it never records, is
+  [ADR `0090`](https://github.com/Wieedze/ARP/blob/main/.claude/choices/0090-what-the-hook-records.md).
+
+## The Claude Code plugin
+
+The plugin carries this program as one file, `bin/arp.js`, so it needs Node 22 and nothing from npm:
+
+```
+claude plugin marketplace add <a checkout of this repo, or owner/repo>
+claude plugin install arp@arp
+```
+
+With no `arp` on `PATH`, its commands stand in for `arp share` and `arp line`. A person types them, and the model cannot invoke them:
+
+A session that allows `Bash` can still run the file itself: that rests on your permissions.
+
+```
+/arp:share         what would be public, and what stays here. Sends nothing
+/arp:share-on      turn sharing on (off by default). Sends nothing
+/arp:share-off     turn it off
+/arp:share-send    write the shared failures as public lines on testnet. Needs a sponsoring service
+/arp:line          write one public line on testnet: --tool <url> --outcome worked|failed
+```
+
+The search in `arp_pulse` still runs `npx skills`: `npx` comes with Node, and that package comes from the npm registry. Installed from a local path, the plugin is read from that path, so keep the folder where it is.
+
+## Install into your runtime
+
+```
+arp init --dry-run     see what would change
+arp init               do it: asks first, backs up every file it edits
+arp doctor             check it: entries present, hook in place, the server answers
+```
+
+`init` finds Claude Code, Grok Build, Cursor, Gemini CLI, Codex and Copilot (VS Code, CLI) on this machine. It adds the MCP
+server to each one, and the hook to Claude Code (Grok Build reads Claude Code's files). For any
+other MCP client, `arp init --print` prints the entry to paste. `--yes` and `--no-input` are for
+scripts, `--runtime claude,cursor` narrows the run, and `--project` writes the project's files.
+
+`init` does not replace an MCP server named `arp` that it did not write. It leaves it, says so, does the rest and exits 6. Rename yours, or pass `--force` to replace it; a file is backed up first. Through the `claude` command there is no backup, so the old entry is printed before it is removed.
+
+## Uninstall
+
+```
+arp uninstall          removes what init added, and nothing else
+npm uninstall -g @arp-protocol/cli
+```
+
+The `.arp/` directory in each project is the hook's log. Delete it if you want it gone.

package/dist/chunks/backfill-j4hxt1w1.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  SKILL_DOMAINS,
+  classifySkill,
+  inferDomain,
+  readRequires
+} from "./cli-74hv4etk.js";
+import"./cli-c8568g4c.js";
+import"./cli-v446mw5v.js";
+import"./cli-0hqxver6.js";
+import"./cli-d3dy7cxe.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+
+// ../hook/src/backfill.ts
+import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, join as join2 } from "node:path";
+
+// ../hook/src/classify.ts
+var CANCELLED = /\b(interrupted|cancel(l)?ed|aborted) by (the )?user\b|\buser (rejected|denied|declined)\b|\bpermission denied by user\b|\buser doesn't want to (proceed|take this action)\b/i;
+function isCancelled(text) {
+  return CANCELLED.test(text);
+}
+
+// ../hook/src/append.ts
+import { closeSync, constants, lstatSync, openSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+function appendOwn(path, text) {
+  if (lstatSync(dirname(path)).isSymbolicLink())
+    throw new Error(`${dirname(path)} is a symbolic link`);
+  const flags = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0);
+  const fd = openSync(path, flags, 384);
+  try {
+    writeSync(fd, text);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// ../hook/src/skill-failure.ts
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join } from "node:path";
+var MISSING_KEY = /\b(api[ _-]?key|access[ _-]?token|credentials?)\b.{0,40}\b(missing|not set|not found|required|invalid|expired)\b|(?<!\bnot )\b(missing|no|invalid|expired)\b.{0,20}\b(api[ _-]?key|access[ _-]?token|credentials?)\b|\b(HTTP|status)(\/[\d.]+| code)?[ :=]*(401|403)\b|\b(401|403) (unauthori[sz]ed|forbidden)\b|\bunauthori[sz]ed\b|not authenticated|not logged in/i;
+var MISSING_KEY_VARIABLE = /\b[A-Z0-9_]*(API_KEY|TOKEN|SECRET)\b.{0,30}\b(not set|missing|required|unset)\b/;
+var MISSING_PROGRAM = /command not found|executable file not found|\bnot installed\b|No module named|spawn \S+ ENOENT|Cannot find module/i;
+var MISSING_FILE = /No such file or directory|\bENOENT\b|file not found|\b(file|path|directory|folder)\b(?!\.).{0,80}\bdoes not exist\b/i;
+function failureReason(text) {
+  if (MISSING_PROGRAM.test(text))
+    return "missing-program";
+  if (MISSING_KEY.test(text) || MISSING_KEY_VARIABLE.test(text))
+    return "missing-key";
+  if (MISSING_FILE.test(text))
+    return "missing-file";
+  return null;
+}
+var RUNNERS = new Set(["bash", "bun", "bunx", "node", "npx", "python", "python3", "sh", "uv", "uvx", "zsh"]);
+function programsOf(command) {
+  const found = [];
+  for (const part of command.split(/&&|\|\||[;|\n]/)) {
+    const words = part.trim().split(/\s+/).filter((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word));
+    const first = words[0];
+    if (first === undefined || first === "")
+      continue;
+    const program = first.split("/").pop() ?? first;
+    if (!RUNNERS.has(program)) {
+      found.push(program);
+      continue;
+    }
+    const target = words.slice(1).find((word) => !word.startsWith("-") && word !== "run");
+    if (target !== undefined)
+      found.push(target.split("/").pop() ?? target);
+  }
+  return found;
+}
+var escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function askedBySkill(command, markdown, directory) {
+  if (new RegExp(`${escaped(directory)}(?=[/\\s'"]|$)`).test(command))
+    return true;
+  const { cli, runs } = readRequires(markdown);
+  const named = new Set([...cli, ...runs]);
+  return programsOf(command).some((program) => named.has(program) || program.includes(".") && new RegExp(`(?:^|[\\s\`'"/(])${escaped(program)}(?=[\\s\`'")]|$)`, "m").test(markdown));
+}
+var DOMAINS = [...new Set(SKILL_DOMAINS.map((rule) => rule.domain))];
+function contextOf(words, skill, description) {
+  return inferDomain(words, DOMAINS) ?? classifySkill(skill.split(":").pop() ?? skill, description ?? "");
+}
+function skillDirectory(name, cwd) {
+  const roots = [join(cwd, ".claude", "skills"), join(homedir(), ".claude", "skills")];
+  const given = process.env["ARP_SKILLS_DIR"];
+  if (given !== undefined && given !== "")
+    roots.unshift(given);
+  return roots.map((root) => join(root, name)).find((dir) => existsSync(join(dir, "SKILL.md"))) ?? null;
+}
+function arpHome() {
+  const given = process.env["ARP_HOME"]?.trim();
+  return given !== undefined && given !== "" ? given : join(homedir(), ".arp");
+}
+function appendFailure(line) {
+  const path = join(arpHome(), "failures.jsonl");
+  const seen = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const key = `"session":${JSON.stringify(line.session)},"skill":${JSON.stringify(line.skill)},`;
+  if (seen.split(`
+`).some((row) => row.includes(key) && row.includes(`"reason":"${line.reason}"`)))
+    return false;
+  mkdirSync(dirname2(path), { recursive: true });
+  appendOwn(path, `${JSON.stringify(line)}
+`);
+  return true;
+}
+
+// ../hook/src/backfill.ts
+var BODY = /^Base directory for this skill: ([^\n]+)/;
+function blocksOf(content) {
+  return Array.isArray(content) ? content : [];
+}
+function textOf(content) {
+  if (typeof content === "string")
+    return content;
+  return blocksOf(content).map((block) => typeof block?.text === "string" ? block.text : "").join(`
+`);
+}
+var lastPart = (name) => name.split(":").pop() ?? name;
+function fromDisk(name, cwd) {
+  try {
+    const directory = skillDirectory(name, cwd);
+    return directory === null ? null : { name, directory, markdown: readFileSync2(join2(directory, "SKILL.md"), "utf8") };
+  } catch {
+    return null;
+  }
+}
+function readTranscript(text, fallback) {
+  const active = [];
+  const commands = new Map;
+  const pending = new Map;
+  const failures = [];
+  let uses = 0;
+  let words = "";
+  for (const line of text.split(`
+`)) {
+    if (!/tool_use|tool_result|Base directory for this skill|"user"/.test(line))
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry["isSidechain"] === true)
+      continue;
+    const message = entry["message"];
+    const content = message?.content;
+    const session = typeof entry["sessionId"] === "string" ? entry["sessionId"] : fallback;
+    const cwd = typeof entry["cwd"] === "string" ? entry["cwd"] : "";
+    const at = typeof entry["timestamp"] === "string" ? entry["timestamp"] : "";
+    if (entry["type"] === "assistant") {
+      for (const block of blocksOf(content)) {
+        if (block?.type !== "tool_use" || typeof block.id !== "string")
+          continue;
+        const input = block.input ?? {};
+        if (block.name === "Skill" && typeof input["skill"] === "string") {
+          uses += 1;
+          pending.set(block.id, input["skill"]);
+          const known = fromDisk(input["skill"], cwd);
+          if (known !== null)
+            active.unshift(known);
+        } else if (block.name === "Bash" && typeof input["command"] === "string") {
+          commands.set(block.id, input["command"]);
+        }
+      }
+      continue;
+    }
+    if (entry["type"] !== "user")
+      continue;
+    const typed = textOf(content);
+    if (entry["isMeta"] !== true && typed.trim() !== "" && !typed.trimStart().startsWith("<"))
+      words = typed;
+    const directory = BODY.exec(textOf(content))?.[1]?.trim();
+    if (entry["isMeta"] === true && directory !== undefined) {
+      const folder = basename(directory);
+      const call = [...pending].find(([, name2]) => lastPart(name2) === folder);
+      if (call === undefined)
+        uses += 1;
+      else
+        pending.delete(call[0]);
+      const name = call?.[1] ?? folder;
+      const known = active.findIndex((skill) => skill.name === name);
+      if (known !== -1)
+        active.splice(known, 1);
+      active.unshift({ name, directory, markdown: textOf(content) });
+      continue;
+    }
+    for (const block of blocksOf(content)) {
+      if (block?.type !== "tool_result" || typeof block.tool_use_id !== "string")
+        continue;
+      if (block.is_error === true)
+        pending.delete(block.tool_use_id);
+      if (block.is_error !== true)
+        continue;
+      const command = commands.get(block.tool_use_id);
+      if (command === undefined)
+        continue;
+      const output = textOf(block.content).slice(0, 4000);
+      if (isCancelled(output))
+        continue;
+      const reason = failureReason(output);
+      if (reason === null)
+        continue;
+      const skill = active.find((candidate) => askedBySkill(command, candidate.markdown, candidate.directory));
+      if (skill === undefined)
+        continue;
+      const domain = contextOf(words, skill.name, readRequires(skill.markdown).description);
+      failures.push({ at, session, skill: skill.name, source: null, ...domain === null ? {} : { domain }, reason });
+    }
+  }
+  return { uses, failures };
+}
+function transcripts(root) {
+  const found = [];
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return found;
+  }
+  for (const name of names) {
+    const path = join2(root, name);
+    try {
+      if (statSync(path).isDirectory())
+        found.push(...transcripts(path));
+      else if (name.endsWith(".jsonl"))
+        found.push(path);
+    } catch {
+      continue;
+    }
+  }
+  return found;
+}
+function backfill(root = join2(homedir2(), ".claude", "projects")) {
+  const files = transcripts(root);
+  let uses = 0;
+  let added = 0;
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync2(file, "utf8");
+    } catch {
+      continue;
+    }
+    const read = readTranscript(text, basename(file, ".jsonl"));
+    uses += read.uses;
+    for (const failure of read.failures)
+      if (appendFailure(failure))
+        added += 1;
+  }
+  return { transcripts: files.length, uses, added, file: join2(arpHome(), "failures.jsonl") };
+}
+export {
+  readTranscript,
+  backfill
+};

package/dist/chunks/ccip-qmytgn8e.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import {
+  HttpRequestError,
+  call,
+  decodeErrorResult,
+  getAbortError,
+  getUrl,
+  isAbortError,
+  isAddressEqual,
+  localBatchGatewayRequest,
+  localBatchGatewayUrl
+} from "./cli-c8568g4c.js";
+import {
+  BaseError,
+  concat,
+  encodeAbiParameters,
+  isHex,
+  stringify
+} from "./cli-0hqxver6.js";
+import"./cli-3kbbwfbp.js";
+import"./cli-g5zvr10v.js";
+
+// ../../node_modules/.bun/viem@2.52.0+1cd18485b0404aca/node_modules/viem/_esm/errors/ccip.js
+class OffchainLookupError extends BaseError {
+  constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
+    super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
+      cause,
+      metaMessages: [
+        ...cause.metaMessages || [],
+        cause.metaMessages?.length ? "" : [],
+        "Offchain Gateway Call:",
+        urls && [
+          "  Gateway URL(s):",
+          ...urls.map((url) => `    ${getUrl(url)}`)
+        ],
+        `  Sender: ${sender}`,
+        `  Data: ${data}`,
+        `  Callback selector: ${callbackSelector}`,
+        `  Extra data: ${extraData}`
+      ].flat(),
+      name: "OffchainLookupError"
+    });
+  }
+}
+
+class OffchainLookupResponseMalformedError extends BaseError {
+  constructor({ result, url }) {
+    super("Offchain gateway response is malformed. Response data must be a hex value.", {
+      metaMessages: [
+        `Gateway URL: ${getUrl(url)}`,
+        `Response: ${stringify(result)}`
+      ],
+      name: "OffchainLookupResponseMalformedError"
+    });
+  }
+}
+
+class OffchainLookupSenderMismatchError extends BaseError {
+  constructor({ sender, to }) {
+    super("Reverted sender address does not match target contract address (`to`).", {
+      metaMessages: [
+        `Contract address: ${to}`,
+        `OffchainLookup sender address: ${sender}`
+      ],
+      name: "OffchainLookupSenderMismatchError"
+    });
+  }
+}
+
+// ../../node_modules/.bun/viem@2.52.0+1cd18485b0404aca/node_modules/viem/_esm/utils/ccip.js
+var offchainLookupSignature = "0x556f1830";
+var offchainLookupAbiItem = {
+  name: "OffchainLookup",
+  type: "error",
+  inputs: [
+    {
+      name: "sender",
+      type: "address"
+    },
+    {
+      name: "urls",
+      type: "string[]"
+    },
+    {
+      name: "callData",
+      type: "bytes"
+    },
+    {
+      name: "callbackFunction",
+      type: "bytes4"
+    },
+    {
+      name: "extraData",
+      type: "bytes"
+    }
+  ]
+};
+async function offchainLookup(client, { blockNumber, blockTag, data, requestOptions, to }) {
+  const { args } = decodeErrorResult({
+    data,
+    abi: [offchainLookupAbiItem]
+  });
+  const [sender, urls, callData, callbackSelector, extraData] = args;
+  const { ccipRead } = client;
+  const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
+  try {
+    if (!isAddressEqual(to, sender))
+      throw new OffchainLookupSenderMismatchError({ sender, to });
+    const result = urls.includes(localBatchGatewayUrl) ? await localBatchGatewayRequest({
+      data: callData,
+      ccipRequest: (parameters) => ccipRequest_({ ...parameters, requestOptions })
+    }) : await ccipRequest_({ data: callData, requestOptions, sender, urls });
+    const { data: data_ } = await call(client, {
+      blockNumber,
+      blockTag,
+      data: concat([
+        callbackSelector,
+        encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
+      ]),
+      requestOptions,
+      to
+    });
+    return data_;
+  } catch (err) {
+    if (requestOptions?.signal?.aborted)
+      throw getAbortError(requestOptions.signal);
+    if (isAbortError(err))
+      throw err;
+    throw new OffchainLookupError({
+      callbackSelector,
+      cause: err,
+      data,
+      extraData,
+      sender,
+      urls
+    });
+  }
+}
+async function ccipRequest({ data, requestOptions, sender, urls }) {
+  let error = new Error("An unknown error occurred.");
+  for (let i = 0;i < urls.length; i++) {
+    if (requestOptions?.signal?.aborted)
+      throw getAbortError(requestOptions.signal);
+    const url = urls[i];
+    const method = url.includes("{data}") ? "GET" : "POST";
+    const body = method === "POST" ? { data, sender } : undefined;
+    const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
+    try {
+      const response = await fetch(url.replace("{sender}", sender.toLowerCase()).replace("{data}", data), {
+        body: JSON.stringify(body),
+        headers,
+        method,
+        ...requestOptions?.signal ? { signal: requestOptions.signal } : {}
+      });
+      let result;
+      if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+        result = (await response.json()).data;
+      } else {
+        result = await response.text();
+      }
+      if (!response.ok) {
+        error = new HttpRequestError({
+          body,
+          details: result?.error ? stringify(result.error) : response.statusText,
+          headers: response.headers,
+          status: response.status,
+          url
+        });
+        continue;
+      }
+      if (!isHex(result)) {
+        error = new OffchainLookupResponseMalformedError({
+          result,
+          url
+        });
+        continue;
+      }
+      return result;
+    } catch (err) {
+      if (requestOptions?.signal?.aborted)
+        throw getAbortError(requestOptions.signal);
+      if (isAbortError(err))
+        throw err;
+      error = new HttpRequestError({
+        body,
+        details: err.message,
+        url
+      });
+    }
+  }
+  throw error;
+}
+export {
+  offchainLookupSignature,
+  offchainLookupAbiItem,
+  offchainLookup,
+  ccipRequest
+};