@arp-protocol/cli 0.0.0-stage → 0.0.3

package/dist/chunks/share-vtbkzs5f.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import {
+  decideShare,
+  installedFromReceipts,
+  installedFromSkillLock,
+  isSharingOn,
+  parseLocalFailures,
+  parseLocalOutcomes,
+  sharedLineKey
+} 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";
+
+// src/share.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var read = (path) => existsSync(path) ? readFileSync(path, "utf8") : null;
+function shared(env) {
+  const keys = new Set;
+  for (const row of (read(join(env.arpHome, "shared-failures.jsonl")) ?? "").split(`
+`)) {
+    if (row.trim() === "")
+      continue;
+    try {
+      keys.add(sharedLineKey(JSON.parse(row)));
+    } catch {
+      continue;
+    }
+  }
+  return keys;
+}
+function decide(env) {
+  const on = isSharingOn(read(join(env.arpHome, "sharing.json")));
+  const decision = decideShare({
+    on,
+    failures: parseLocalFailures(read(join(env.arpHome, "failures.jsonl")) ?? ""),
+    outcomes: parseLocalOutcomes(read(join(env.arpHome, "outcomes.jsonl")) ?? ""),
+    installed: [
+      ...installedFromSkillLock(read(join(env.home, ".agents", ".skill-lock.json"))),
+      ...installedFromReceipts(read(join(env.arpHome, "receipts.jsonl"))),
+      ...installedFromReceipts(read(join(env.cwd, ".arp", "receipts.jsonl")))
+    ],
+    alreadyShared: shared(env)
+  });
+  return { ...decision, on };
+}
+function setSharing(env, on) {
+  mkdirSync(env.arpHome, { recursive: true });
+  writeFileSync(join(env.arpHome, "sharing.json"), `${JSON.stringify({ failures: on })}
+`);
+}
+async function sendShared(env, write) {
+  const { on, lines } = decide(env);
+  if (!on)
+    return { sent: 0, failed: 0, firstError: null };
+  let sent = 0;
+  let failed = 0;
+  let firstError = null;
+  for (const line of lines) {
+    try {
+      await write(line);
+      appendFileSync(join(env.arpHome, "shared-failures.jsonl"), `${JSON.stringify(line)}
+`);
+      sent += 1;
+    } catch (error) {
+      failed += 1;
+      firstError ??= error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { sent, failed, firstError };
+}
+var WHY = {
+  sharing_off: "sharing is off",
+  no_public_source: "no known public source",
+  several_sources: "several sources with this name"
+};
+function describe(decision) {
+  const out = [`sharing is ${decision.on ? "on" : "off"}`];
+  if (decision.lines.length > 0) {
+    out.push("", "would be public on testnet 13579:");
+    for (const line of decision.lines) {
+      const tail = line.outcome === "failed" ? `failed  ${line.reason}${line.need === undefined ? "" : `  needs ${line.need}`}` : `worked${line.need === undefined ? "" : `  with ${line.need}`}`;
+      out.push(`  ${line.toolUrl}  ${line.domain ?? "(no domain)"}  ${tail}`);
+    }
+  }
+  if (decision.keptLocal.length > 0) {
+    out.push("", "stays on this machine:");
+    for (const row of decision.keptLocal)
+      out.push(`  ${row.skill}: ${WHY[row.why]}`);
+  }
+  return `${out.join(`
+`)}
+`;
+}
+export {
+  setSharing,
+  sendShared,
+  describe,
+  decide
+};

package/dist/cli.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+import {
+  bufferedCopy
+} from "./chunks/cli-n4qagybd.js";
+import"./chunks/cli-fbwpcfvp.js";
+import"./chunks/cli-mhzh9z8k.js";
+import"./chunks/cli-d3dy7cxe.js";
+import"./chunks/cli-3kbbwfbp.js";
+import {
+  __require
+} from "./chunks/cli-g5zvr10v.js";
+
+// src/cli.ts
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// package.json
+var version = "0.0.3";
+
+// src/cli.ts
+var USAGE = `arp ${version} — ARP's agent-side programs
+
+usage
+  arp mcp [--http]   the MCP server. stdio by default, which is how an MCP client launches it
+  arp hook           the runtime hook: one payload on stdin. Records what a session used in
+                     .arp/session.jsonl, and a skill's failures in ~/.arp/failures.jsonl. On
+                     Stop, asks once per skill whether it did its job: ~/.arp/outcomes.jsonl
+  arp backfill       read old Claude Code transcripts into ~/.arp/failures.jsonl. Sends nothing
+  arp share          say what would be public from ~/.arp/failures.jsonl and outcomes.jsonl,
+                     and what stays here.
+                     arp share on, off (off by default). arp share send writes them on testnet
+  arp node           the hire endpoint. Opt-in: it listens on 127.0.0.1 and is reached through
+                     a tunnel you rent (cloudflared or ngrok, or ARP_NODE_PUBLIC_URL)
+
+  arp line           write one public line on testnet 13579 through ARP's sponsor: --tool <url>
+                     --outcome worked|failed [--domain <category>] [--reason <reason>]
+                     [--payment-tx <hash> --network eip155:8453]  an x402 payment, read on Base;
+                     with it, --tool is the exact URL you paid
+                     [--needs <name>] or [--with <name>]  the program or variable name that was
+                     missing, or that you added; written only if the skill's SKILL.md names it
+  arp init           add the MCP server and the hook to every runtime found here
+  arp uninstall      remove them, and only them
+  arp doctor         check what is installed and that the server answers
+  arp init --node    bind this node to your ERC-8004 agent: the token's owner signs once
+                     --agent-registry eip155:<chain>:<registry> --agent-id <id>
+                     --endpoint <https URL> --directory <handshake URL>
+
+  options for init, uninstall, doctor
+    --dry-run, -n        show the changes, write nothing
+    --yes, -y            agree without a prompt
+    --no-input           never prompt; fail if a change needs agreement
+    --runtime a,b        only these: claude, grok, cursor, gemini, codex, copilot
+    --project            the project's files instead of your user ones
+    --print              (init) print the MCP entry for any other client, write nothing
+    --sponsored          (init) testnet tools that sign nothing for the user: ARP's sponsor
+                         pays, and a fetched skill is installed into .claude/skills once you
+                         accept the question it shows
+    --capture            (init) hook every runtime and keep each payload, redacted, in
+                         ~/.arp/captures/ — to teach the hook a new runtime
+    --force              (init) replace an MCP server named "arp" that ARP did not write
+    --share, --no-share  (init) answer the sharing offer up front; off unless --share or a "y"
+  arp --version
+  arp --help
+
+docs: https://github.com/intuition-box/ARP/blob/main/docs/22_RUNNING_THE_NODE.md
+`;
+var EXIT = { ok: 0, usage: 2, writeFailed: 5 };
+var CLI_PATH = fileURLToPath(import.meta.url);
+var ARGV = process.argv.slice(2);
+var asksHelp = (rest) => rest.some((arg) => arg === "--help" || arg === "-h");
+var WANTS_HELP = asksHelp(ARGV.slice(1));
+var STDIO_INPUT = ARGV[0] === "mcp" && !ARGV.includes("--http") && !WANTS_HELP ? bufferedCopy(process.stdin) : undefined;
+async function runNodeInit(rest) {
+  const { nodeInit, parseNodeInitFlags } = await import("./chunks/node-init-rcepfyeh.js");
+  const flags = parseNodeInitFlags(rest);
+  if (flags instanceof Error) {
+    process.stderr.write(`arp init --node: ${flags.message}
+`);
+    return EXIT.usage;
+  }
+  const { homedir } = await import("node:os");
+  const { createInterface } = await import("node:readline/promises");
+  return nodeInit(flags, {
+    env: process.env,
+    home: homedir(),
+    interactive: process.stdin.isTTY === true,
+    readLine: async (prompt) => {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      try {
+        return await rl.question(prompt);
+      } finally {
+        rl.close();
+      }
+    },
+    out: (line) => process.stdout.write(`${line}
+`),
+    err: (line) => process.stderr.write(`${line}
+`)
+  });
+}
+async function shareCommand(rest) {
+  const { arpHome } = await import("./chunks/index-jrs2shcc.js");
+  const { homedir } = await import("node:os");
+  const share = await import("./chunks/share-vtbkzs5f.js");
+  const env = { arpHome: arpHome(process.env, homedir()), home: homedir(), cwd: process.cwd() };
+  if (rest[0] === "send") {
+    if (!share.decide(env).on) {
+      process.stderr.write("sharing is off: nothing was sent. `arp share on` turns it on\n");
+      return EXIT.ok;
+    }
+    process.env["ARP_TARGET"] ??= "testnet";
+    const { writeLineHere } = await import("./chunks/line-691gbaha.js");
+    const done = await share.sendShared(env, async (line) => {
+      await writeLineHere(line);
+    });
+    process.stdout.write(`sent ${done.sent}, failed ${done.failed}
+`);
+    if (done.firstError !== null)
+      process.stderr.write(`${done.firstError}
+`);
+    return done.failed === 0 ? EXIT.ok : 1;
+  }
+  if (rest[0] === "on" || rest[0] === "off")
+    share.setSharing(env, rest[0] === "on");
+  else if (rest[0] !== undefined) {
+    process.stderr.write(`usage: arp share [on|off|send]
+`);
+    return EXIT.usage;
+  }
+  process.stdout.write(share.describe(share.decide(env)));
+  return EXIT.ok;
+}
+async function run(argv) {
+  const [command, ...rest] = argv;
+  if (asksHelp(rest)) {
+    process.stdout.write(USAGE);
+    return EXIT.ok;
+  }
+  if (command === "init" && rest.includes("--node"))
+    return runNodeInit(rest);
+  switch (command) {
+    case "mcp": {
+      const { main } = await import("./chunks/server-59zry2jp.js");
+      await main(rest.includes("--http") ? rest : ["--stdio", ...rest], STDIO_INPUT);
+      return EXIT.ok;
+    }
+    case "hook":
+      await import(new URL("./hook.js", import.meta.url).href);
+      return EXIT.ok;
+    case "share":
+      try {
+        return await shareCommand(rest);
+      } catch (error) {
+        process.stderr.write(`arp share: ${error instanceof Error ? error.message : String(error)}
+`);
+        return EXIT.writeFailed;
+      }
+    case "line": {
+      const flag = (name) => {
+        const at = rest.indexOf(`--${name}`);
+        return at === -1 ? undefined : rest[at + 1];
+      };
+      const toolUrl = flag("tool");
+      const outcome = flag("outcome");
+      if (toolUrl === undefined || outcome === undefined) {
+        process.stderr.write(`usage: arp line --tool <url> --outcome worked|failed [--domain <category>] [--reason <reason>]
+       [--parent <category> --why <text>]   adds a --domain the tree lacks, under --parent
+       [--payment-tx <hash> --network eip155:8453]   the x402 payment this outcome refers to;
+                                                     --tool is then the exact URL you paid
+       [--needs <name>]   with missing-program or missing-key: the program or variable name (never a value)
+       [--with <name>]    with --outcome worked: what you had to add; either is written only if the SKILL.md names it
+`);
+        return EXIT.usage;
+      }
+      process.env["ARP_TARGET"] ??= "testnet";
+      const { lineFromArgs, writeLineHere } = await import("./chunks/line-691gbaha.js");
+      const input = lineFromArgs({
+        toolUrl,
+        outcome,
+        domain: flag("domain"),
+        reason: flag("reason"),
+        parent: flag("parent"),
+        why: flag("why"),
+        paymentTx: flag("payment-tx"),
+        network: flag("network"),
+        needs: flag("needs"),
+        with: flag("with")
+      });
+      if (input instanceof Error) {
+        process.stderr.write(`arp line: ${input.message}
+`);
+        return EXIT.usage;
+      }
+      try {
+        const written = await writeLineHere(input);
+        process.stdout.write(`${JSON.stringify(written)}
+`);
+        return EXIT.ok;
+      } catch (error) {
+        process.stderr.write(`arp line: ${error instanceof Error ? error.message : String(error)}
+`);
+        return 1;
+      }
+    }
+    case "backfill": {
+      const { backfill } = await import("./chunks/backfill-awengrsd.js");
+      const found = backfill();
+      process.stdout.write(`read ${found.transcripts} transcripts: ${found.uses} skill uses, ${found.added} new failures in ${found.file}
+`);
+      return EXIT.ok;
+    }
+    case "node": {
+      const { main } = await import("./chunks/node-m0mx4y5k.js");
+      await main();
+      return EXIT.ok;
+    }
+    case "init":
+    case "uninstall":
+    case "doctor": {
+      const install = await import("./chunks/commands-157bms70.js");
+      const { processEnv } = await import("./chunks/env-n5ac8d1z.js");
+      const flags = install.parseFlags(rest);
+      if (flags instanceof Error) {
+        process.stderr.write(`arp ${command}: ${flags.message}
+`);
+        return EXIT.usage;
+      }
+      const env = processEnv(dirname(CLI_PATH), version);
+      if (command === "doctor")
+        return install.doctor(env, flags, CLI_PATH);
+      return command === "init" ? install.init(env, flags, CLI_PATH) : install.uninstall(env, flags, CLI_PATH);
+    }
+    case "--version":
+    case "-v":
+      process.stdout.write(`${version}
+`);
+      return EXIT.ok;
+    case undefined:
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(USAGE);
+      return EXIT.ok;
+    default:
+      process.stderr.write(`arp: unknown command '${command}'
+
+${USAGE}`);
+      return EXIT.usage;
+  }
+}
+process.stdout.on("error", (error) => {
+  if (error.code === "EPIPE")
+    process.exit(0);
+  throw error;
+});
+run(ARGV).then((code) => {
+  if (code !== EXIT.ok)
+    process.exit(code);
+});