@arp-protocol/cli 0.0.3 → 0.0.5

package/dist/chunks/share-k1dnzsna.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+import {
+  decideShare,
+  installedFromReceipts,
+  installedFromSkillLock,
+  isSharingOn,
+  parseLocalFailures,
+  parseLocalOutcomes,
+  sharedLineKey,
+  sharingChoiceOf,
+  sharingFileText
+} from "./cli-g3q6fxm0.js";
+import"./cli-zehr6kdx.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, rmSync, 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 onceGrants(env) {
+  const grants = [];
+  for (const row of (read(join(env.arpHome, "share-once.jsonl")) ?? "").split(`
+`)) {
+    try {
+      const { session, skill } = JSON.parse(row);
+      if (typeof session === "string" && typeof skill === "string")
+        grants.push({ session, skill });
+    } catch {
+      continue;
+    }
+  }
+  return grants;
+}
+var nameOf = (skill) => skill.split(":").pop() ?? skill;
+function granted(text, grants, since = null) {
+  return text.split(`
+`).filter((row) => {
+    try {
+      const { session, skill, at } = JSON.parse(row);
+      if (since !== null && typeof at === "string" && at >= since)
+        return true;
+      return grants.some((grant) => grant.session === session && typeof skill === "string" && nameOf(skill) === nameOf(grant.skill));
+    } catch {
+      return false;
+    }
+  }).join(`
+`);
+}
+var rowCount = (text) => text.split(`
+`).filter((row) => row.trim() !== "").length;
+function decide(env) {
+  const choice = sharingChoiceOf(read(join(env.arpHome, "sharing.json")));
+  const on = isSharingOn(read(join(env.arpHome, "sharing.json")));
+  const since = on && choice?.how === "asked-always" && choice.at !== null ? choice.at : null;
+  const grants = on && since === null ? [] : onceGrants(env);
+  const failuresAll = read(join(env.arpHome, "failures.jsonl")) ?? "";
+  const outcomesAll = read(join(env.arpHome, "outcomes.jsonl")) ?? "";
+  const failuresText = since === null ? failuresAll : granted(failuresAll, grants, since);
+  const outcomesText = since === null ? outcomesAll : granted(outcomesAll, grants, since);
+  const earlier = rowCount(failuresAll) + rowCount(outcomesAll) - rowCount(failuresText) - rowCount(outcomesText);
+  const installed = [
+    ...installedFromSkillLock(read(join(env.home, ".agents", ".skill-lock.json"))),
+    ...installedFromSkillLock(read(join(env.cwd, "skills-lock.json"))),
+    ...installedFromReceipts(read(join(env.arpHome, "receipts.jsonl"))),
+    ...installedFromReceipts(read(join(env.cwd, ".arp", "receipts.jsonl")))
+  ];
+  const alreadyShared = shared(env);
+  const all = decideShare({
+    on,
+    failures: parseLocalFailures(failuresText),
+    outcomes: parseLocalOutcomes(outcomesText),
+    installed,
+    alreadyShared
+  });
+  if (on || grants.length === 0)
+    return { ...all, on, choice, once: false, earlier };
+  const once = decideShare({
+    on: true,
+    failures: parseLocalFailures(granted(failuresText, grants)),
+    outcomes: parseLocalOutcomes(granted(outcomesText, grants)),
+    installed,
+    alreadyShared
+  });
+  const onceSkills = new Set(grants.map((grant) => nameOf(grant.skill)));
+  const stillOff = all.keptLocal.filter((row) => !onceSkills.has(row.skill));
+  return { lines: once.lines, keptLocal: [...once.keptLocal, ...stillOff], on, choice, once: once.lines.length > 0, earlier: 0 };
+}
+function setSharing(env, on, how = "command", now = new Date) {
+  mkdirSync(env.arpHome, { recursive: true });
+  writeFileSync(join(env.arpHome, "sharing.json"), sharingFileText(on, how, now));
+}
+var LOCK = "share-send.lock";
+var STALE_MS = 10 * 60 * 1000;
+async function withSendLock(env, send, now = Date.now) {
+  mkdirSync(env.arpHome, { recursive: true });
+  const path = join(env.arpHome, LOCK);
+  const take = () => {
+    try {
+      writeFileSync(path, `${JSON.stringify({ pid: process.pid, at: new Date(now()).toISOString() })}
+`, { flag: "wx" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!take()) {
+    let at = 0;
+    try {
+      at = Date.parse(JSON.parse(readFileSync(path, "utf8")).at ?? "");
+    } catch {
+      at = 0;
+    }
+    if (Number.isFinite(at) && now() - at < STALE_MS)
+      return null;
+    rmSync(path, { force: true });
+    if (!take())
+      return null;
+  }
+  try {
+    return await send();
+  } finally {
+    rmSync(path, { force: true });
+  }
+}
+function logSend(env, result, now = new Date) {
+  mkdirSync(env.arpHome, { recursive: true });
+  const row = { at: now.toISOString(), sent: result.sent, failed: result.failed, ...result.firstError === null ? {} : { error: result.firstError } };
+  appendFileSync(join(env.arpHome, "share-log.jsonl"), `${JSON.stringify(row)}
+`);
+}
+async function sendShared(env, write) {
+  const { on, once, lines } = decide(env);
+  if (!on && !once)
+    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"
+};
+var HOW = {
+  init: "at install",
+  command: "by command",
+  desktop: "in Claude Desktop's settings",
+  "asked-once": 'answering "yes, this once"',
+  "asked-always": 'answering "always"',
+  "asked-no": 'answering "no"'
+};
+function status(decision) {
+  const state = decision.on ? "on" : "off";
+  if (decision.choice === null)
+    return `sharing is ${state}, not decided yet`;
+  const when = decision.choice.at === null ? "" : ` ${decision.choice.at.slice(0, 10)}`;
+  const how = decision.choice.how === null ? "" : ` ${HOW[decision.choice.how]}`;
+  return when === "" && how === "" ? `sharing is ${state}` : `sharing is ${state}, chosen${when}${how}`;
+}
+function describe(decision) {
+  const out = [status(decision)];
+  if (decision.lines.length > 0) {
+    out.push("", decision.on ? "would be public on testnet 13579:" : "would be public on testnet 13579, agreed once:");
+    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]}`);
+  }
+  if (decision.earlier > 0) {
+    out.push("", `kept before "always" was chosen, and staying here: ${decision.earlier} record(s). \`arp share on\` would show and include them`);
+  }
+  return `${out.join(`
+`)}
+`;
+}
+export {
+  withSendLock,
+  setSharing,
+  sendShared,
+  logSend,
+  describe,
+  decide
+};

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 // package.json
-var version = "0.0.3";
+var version = "0.0.5";
 
 // src/cli.ts
 var USAGE = `arp ${version} — ARP's agent-side programs
@@ -23,18 +23,26 @@ 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
+                     Stop, asks once per skill whether it did its job: ~/.arp/outcomes.jsonl.
+                     While sharing is undecided, the first result also asks once whether to share
+                     it; with sharing on, SessionEnd starts arp share send --auto in the background
   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 share on, off (off by default). arp share send writes them on testnet;
+                     --auto prints nothing and keeps the result in ~/.arp/share-log.jsonl
+  arp check <skill>  before you use a skill: what its files contain, what agents wrote about
+                     it, and whether what it needed when it failed is on this machine.
+                     <owner/repo/skill> or a github.com URL with ?skill=. Writes nothing
   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
+                     with it, --tool is the exact URL you paid, written
+                     with its values removed, and the 402's terms you paid
+                     against: --pay-to --asset --price --terms-at
                      [--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
@@ -70,7 +78,7 @@ 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 { nodeInit, parseNodeInitFlags } = await import("./chunks/node-init-rmrmmg59.js");
   const flags = parseNodeInitFlags(rest);
   if (flags instanceof Error) {
     process.stderr.write(`arp init --node: ${flags.message}
@@ -100,18 +108,42 @@ async function runNodeInit(rest) {
 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() };
+  const share = await import("./chunks/share-k1dnzsna.js");
+  const cwd = process.env["ARP_PROJECT_DIR"]?.trim() || process.cwd();
+  const env = { arpHome: arpHome(process.env, homedir()), home: homedir(), 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");
+    const auto = rest.includes("--auto");
+    const decision = share.decide(env);
+    if (!decision.on && !decision.once) {
+      if (!auto)
+        process.stderr.write("sharing is off: nothing was sent. `arp share on` turns it on\n");
       return EXIT.ok;
     }
+    if (auto && decision.lines.length === 0)
+      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);
-    });
+    let done;
+    try {
+      const { writeLineHere } = await import("./chunks/line-wra91qkr.js");
+      done = await share.withSendLock(env, () => share.sendShared(env, async (line) => {
+        await writeLineHere(line);
+      }));
+    } catch (error) {
+      if (!auto)
+        throw error;
+      share.logSend(env, { sent: 0, failed: 0, firstError: error instanceof Error ? error.message : String(error) });
+      return EXIT.ok;
+    }
+    if (done === null) {
+      if (!auto)
+        process.stderr.write(`another send is running: nothing was sent by this one
+`);
+      return EXIT.ok;
+    }
+    if (auto) {
+      share.logSend(env, done);
+      return EXIT.ok;
+    }
     process.stdout.write(`sent ${done.sent}, failed ${done.failed}
 `);
     if (done.firstError !== null)
@@ -139,7 +171,7 @@ async function run(argv) {
     return runNodeInit(rest);
   switch (command) {
     case "mcp": {
-      const { main } = await import("./chunks/server-59zry2jp.js");
+      const { main } = await import("./chunks/server-bcsxfd7q.js");
       await main(rest.includes("--http") ? rest : ["--stdio", ...rest], STDIO_INPUT);
       return EXIT.ok;
     }
@@ -154,6 +186,17 @@ async function run(argv) {
 `);
         return EXIT.writeFailed;
       }
+    case "check": {
+      const { checkSkill, skillRefOf, thisMachine } = await import("./chunks/check-k4qnc9ee.js");
+      const ref = rest.length === 1 ? skillRefOf(rest[0] ?? "") : null;
+      if (ref === null) {
+        process.stderr.write(`usage: arp check <owner/repo/skill | https://github.com/owner/repo?skill=name>
+`);
+        return EXIT.usage;
+      }
+      process.stdout.write(await checkSkill(ref, { env: process.env, machine: thisMachine() }));
+      return EXIT.ok;
+    }
     case "line": {
       const flag = (name) => {
         const at = rest.indexOf(`--${name}`);
@@ -165,14 +208,17 @@ async function run(argv) {
         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
+                                                     --tool is then the exact URL you paid;
+                                                     its values are removed before anything is signed
+` + `       [--pay-to <0x…> --asset <0x…> --price <units> --terms-at <unix|ISO>]   with --payment-tx: the 402's
+` + `                                                     payTo, asset and amount you paid against, and when it came
        [--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 { lineFromArgs, writeLineHere } = await import("./chunks/line-wra91qkr.js");
       const input = lineFromArgs({
         toolUrl,
         outcome,
@@ -182,6 +228,10 @@ async function run(argv) {
         why: flag("why"),
         paymentTx: flag("payment-tx"),
         network: flag("network"),
+        payTo: flag("pay-to"),
+        asset: flag("asset"),
+        price: flag("price"),
+        termsAt: flag("terms-at"),
         needs: flag("needs"),
         with: flag("with")
       });
@@ -202,21 +252,21 @@ async function run(argv) {
       }
     }
     case "backfill": {
-      const { backfill } = await import("./chunks/backfill-awengrsd.js");
+      const { backfill } = await import("./chunks/backfill-kzgeaffa.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");
+      const { main } = await import("./chunks/node-2rw44jrf.js");
       await main();
       return EXIT.ok;
     }
     case "init":
     case "uninstall":
     case "doctor": {
-      const install = await import("./chunks/commands-157bms70.js");
+      const install = await import("./chunks/commands-vvrdahbr.js");
       const { processEnv } = await import("./chunks/env-n5ac8d1z.js");
       const flags = install.parseFlags(rest);
       if (flags instanceof Error) {