@c4roa0/agentpay-user 0.0.0-stage → 0.3.1

package/src/npm-update.mjs

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MPL-2.0
+// Update only a real global npm installation. Source checkouts/npm links are never
+// overwritten. npm selects User; User's exact dependencies select Wallet/Protocol.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { access, appendFile, lstat, mkdir, open, readFile, realpath, unlink } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline/promises';
+import { installedUserDir, resolveUserDataDir, rememberUserDataDir } from './local-data-directory.mjs';
+import { installationDirectory } from './installation-paths.mjs';
+import { prepareOfficialTestUpdate } from './official-test-update.mjs';
+const execute = promisify(execFile);
+const name = '@c4roa0/agentpay-user';
+const stable = value => typeof value === 'string' && /^\d+\.\d+\.\d+$/.test(value);
+function newer(next, current) {
+  const a = next.split('.').map(BigInt), b = current.split('.').map(BigInt);
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return false;
+}
+async function command(file, args, { logPath, timeout = 120000, env = process.env, cwd = process.cwd() } = {}) {
+  try {
+    const result = await execute(file, args, { timeout, cwd, maxBuffer: 2 * 1024 * 1024,
+      env: { ...env, PATH: dirname(process.execPath) + ':' + (env.PATH || '') } });
+    if (logPath) await appendFile(logPath, result.stdout + result.stderr, {mode:0o600});
+    return result.stdout.trim();
+  } catch (error) {
+    if (logPath) await appendFile(logPath, String(error.stdout || '') + String(error.stderr || ''), {mode:0o600});
+    throw Error(logPath ? 'The command did not complete. Check the update log.' : 'Could not query npm. Check your network and npm configuration, then retry.');
+  }
+}
+async function askConfirmation(message) {
+  if (!process.stdin.isTTY) throw Error('Run agentpay update in a terminal, or use -f.');
+  const terminal = createInterface({ input:process.stdin, output:process.stdout });
+  try { return await terminal.question(message + '\n> '); } finally { terminal.close(); }
+}
+export async function updateFromNpm({
+  userDir = installedUserDir, dataDir, force = false, write = console.log,
+  ask = askConfirmation,
+  npm = (args, options) => command('npm', args, options),
+  service = (action, options) => command(process.execPath, [join(userDir,'scripts/autostart.mjs'), action], options),
+  repair = options => command(process.execPath, [join(userDir,'scripts/repair.mjs'), '-f'], options),
+  officialTest = prepareOfficialTestUpdate,
+} = {}) {
+  let lock, lockPath, logPath, installing = false;
+  try {
+    const current = JSON.parse(await readFile(join(userDir, 'package.json'), 'utf8'));
+    if (current.name !== name || !stable(current.version)) throw Error('Unrecognized User installation.');
+    write('Checking for a User update…');
+    const root = await npm(['root','--global']), prefix = await npm(['prefix','--global']);
+    if (!isAbsolute(root) || !isAbsolute(prefix)) throw Error('npm installation paths could not be verified.');
+    const globalPath = join(root, name);
+    const globalInfo = await lstat(globalPath).catch(e => { if(e.code !== 'ENOENT') throw e; return null; });
+    if (!globalInfo || globalInfo.isSymbolicLink() || await realpath(globalPath) !== await realpath(userDir))
+      throw Error('This is a source checkout or linked installation. Update its files, run npm ci, then agentpay repair.');
+    await access(dirname(globalPath), constants.W_OK);
+    const metadata = JSON.parse(await npm(['view',name + '@latest','--global','--json']));
+    if (metadata.name !== name || !stable(metadata.version) ||
+        !stable(metadata.dependencies?.['@c4roa0/agentpay-wallet']) ||
+        !stable(metadata.dependencies?.['@c4roa0/agentpay-protocol']))
+      throw Error('The published User release does not declare reviewed package versions.');
+    dataDir ??= await resolveUserDataDir({userDir});
+    if (!newer(metadata.version,current.version)) {
+      write(`User ${current.version} is current. Checking the official test Skill.`);
+      await officialTest({userDir,dataDir,write});
+      return 0;
+    }
+    write(`User ${current.version} → ${metadata.version} · Wallet ${metadata.dependencies['@c4roa0/agentpay-wallet']}`);
+    write('Background services will pause. Keys, permissions, Orders and cache are kept.');
+    if (!force && (await ask("Type 'confirm' to update, or 'q' to cancel")).trim().toLowerCase() !== 'confirm') {
+      write('Update cancelled. Nothing was changed.'); return 0;
+    }
+    // Persist a custom directory before replacing this package; no key/Policy changes.
+    await rememberUserDataDir({userDir,dataDir});
+    const stateDir = installationDirectory();
+    await mkdir(stateDir,{recursive:true,mode:0o700});
+    logPath = join(stateDir, `update-${Date.now()}-${randomUUID()}.log`);
+    lockPath = join(stateDir,'install.lock');
+    lock = await open(lockPath,'wx',0o600);
+    const rechecked = JSON.parse(await readFile(join(userDir,'package.json'),'utf8'));
+    if (rechecked.version !== current.version || rechecked.name !== name)
+      throw Error('Program files changed while reviewing the update. Run agentpay update again.');
+    const env = {...process.env,AGENTPAY_USER_DATA_DIR:dataDir};
+    const options = {logPath,env,cwd:stateDir,timeout:600000};
+    const spec = name + '@' + metadata.version;
+    const args = ['install','--global','--prefix',prefix,'--engine-strict','--ignore-scripts','--no-audit','--no-fund',spec];
+    write('1/3 Check the update requirements.');
+    await npm([...args,'--dry-run'],options);
+    let configured = false;
+    try { configured = (await lstat(join(dataDir,'runtime/local-services.json'))).isFile(); }
+    catch(e) { if(e.code !== 'ENOENT') throw e; }
+    // All imports used by this updater are loaded before npm replaces its files.
+    if (configured) await service('stop',options);
+    installing = true;
+    write('2/3 Install User and its matching Wallet. This may take a few minutes.');
+    await npm(args,options);
+    const installed = JSON.parse(await readFile(join(userDir,'package.json'),'utf8'));
+    if(installed.name !== name || installed.version !== metadata.version ||
+       installed.dependencies?.['@c4roa0/agentpay-wallet'] !== metadata.dependencies['@c4roa0/agentpay-wallet'] ||
+       installed.dependencies?.['@c4roa0/agentpay-protocol'] !== metadata.dependencies['@c4roa0/agentpay-protocol'])
+      throw Error('The installed version does not match the confirmed update.');
+    // Release before the new version's repair acquires the same lock. Another
+    // operation may win that lock; repair then refuses safely and can be retried.
+    await lock.close(); lock = null; await unlink(lockPath); lockPath = null;
+    if (configured) {
+      write('3/3 Restore services and verify the official test Skill.');
+      // A fresh Node process loads the NEW repair/client/official digest, not old imports.
+      const output = await repair(options);
+      if(output) write(output);
+    } else {
+      write('3/3 Program files are ready. Local setup has not been configured.');
+      write('Next: agentpay install --market YOUR_MARKET_URL');
+    }
+    write(`User ${metadata.version} installed. No paid test was started.`);
+    return 0;
+  } catch(error) {
+    write(installing
+      ? 'Update did not finish. Your private data was kept. Reinstall the intended User version with npm if needed, then run agentpay repair.'
+      : 'Update stopped before replacing program files. ' + (error.code === 'EEXIST' ? 'Another installation is running.' : error.message));
+    if(logPath) write('Log: ' + logPath);
+    return 1;
+  } finally {
+    if(lock) { await lock.close(); await unlink(lockPath); }
+  }
+}

package/src/official-paid-test.mjs

@@ -0,0 +1,407 @@
+// SPDX-License-Identifier: MPL-2.0
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy was not distributed with this file, see https://mozilla.org/MPL/2.0/.
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { open, link, rename, unlink, mkdir, lstat } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createInterface } from "node:readline/promises";
+import { Contract, JsonRpcProvider, formatUnits } from "ethers";
+import { resolveUserDataDir } from "./local-data-directory.mjs";
+import { OFFICIAL_TEST_PACKAGE } from "./official-test-package.mjs";
+import { inspectInstalledBundle } from "./active-skill.mjs";
+import { loadRuntimeConnection, readServiceOffer } from "./runtime-client.mjs";
+import { normalizeAcceptedTerms } from "./service-reference.mjs";
+import { readPrivateFile } from "./runtime-client.mjs";
+import { readServiceSettings } from "./local-services.mjs";
+import { callWallet } from "@c4roa0/agentpay-wallet";
+import { withClientRequestLock } from "./client-request-lock.mjs";
+
+const run = promisify(execFile),
+  version = "agentpay.official-paid-test.v1";
+const input = { min: 10, max: 99 };
+function serviceTime(seconds) {
+  const [value, unit] =
+    seconds % 3600 === 0
+      ? [seconds / 3600, "hour"]
+      : seconds % 60 === 0
+        ? [seconds / 60, "minute"]
+        : [seconds, "second"];
+  return `${value} ${unit}${value === 1 ? "" : "s"}`;
+}
+async function readPrivate(path) {
+  let h;
+  try {
+    h = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const s = await h.stat();
+    if (
+      !s.isFile() ||
+      s.uid !== process.getuid() ||
+      s.mode & 0o077 ||
+      s.size > 16384
+    )
+      throw Error("Official test record is unsafe");
+    return JSON.parse(await h.readFile("utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  } finally {
+    await h?.close();
+  }
+}
+async function save(path, value, replace = false) {
+  const tmp = path + "." + randomUUID() + ".tmp";
+  let h;
+  try {
+    h = await open(tmp, "wx", 0o600);
+    await h.writeFile(JSON.stringify(value) + "\n");
+    await h.sync();
+    await h.close();
+    h = null;
+    if (replace) await rename(tmp, path);
+    else await link(tmp, path);
+    const dir = await open(
+      dirname(path),
+      constants.O_RDONLY | constants.O_DIRECTORY,
+    );
+    try {
+      await dir.sync();
+    } finally {
+      await dir.close();
+    }
+  } finally {
+    await h?.close();
+    await unlink(tmp).catch((e) => {
+      if (e.code !== "ENOENT") throw e;
+    });
+  }
+}
+async function prompt(question) {
+  if (!process.stdin.isTTY)
+    throw Error("Run agentpay payment test in your terminal.");
+  const t = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await t.question(question + "\n> ")).trim().toLowerCase();
+  } finally {
+    t.close();
+  }
+}
+async function archiveCompleted(dataDir, record) {
+  const dir = join(dataDir, "runtime", "official-tests");
+  await mkdir(dir, { mode: 0o700 }).catch((e) => {
+    if (e.code !== "EEXIST") throw e;
+  });
+  const st = await lstat(dir);
+  if (
+    !st.isDirectory() ||
+    st.isSymbolicLink() ||
+    st.uid !== process.getuid() ||
+    st.mode & 0o077
+  )
+    throw Error("Official test history directory is unsafe");
+  const path = join(dir, `${record.requestId}.json`);
+  try {
+    await save(path, record);
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+    const prior = await readPrivate(path);
+    if (JSON.stringify(prior) !== JSON.stringify(record))
+      throw Error("Official test history conflicts with the saved result");
+  }
+}
+function resultIdentity(body) {
+  const r = body?.result;
+  if (
+    body?.ok !== true ||
+    !/^0x[0-9a-f]{64}$/.test(r?.orderId || "") ||
+    !/^0x[0-9a-f]{64}$/.test(r?.outputHash || "") ||
+    r.output?.kind !== "random" ||
+    !Number.isSafeInteger(r.output.value) ||
+    r.output.value < input.min ||
+    r.output.value > input.max ||
+    r.deliveryEvidenceVerified !== true
+  )
+    throw Error(
+      "Official Skill did not return verified delivery. Keep the test record and retry the same request.",
+    );
+  return { orderId: r.orderId, outputHash: r.outputHash };
+}
+async function confirmDelivery(dataDir, orderId) {
+  const token = (
+    await readPrivateFile(join(dataDir, "wallet", "agent.token"), 256)
+  ).trim();
+  if (!/^[0-9a-f]{64}$/.test(token))
+    throw Error("Local Wallet credential is invalid.");
+  const { settlementUrl } = await readServiceSettings(dataDir);
+  const deadline = Date.now() + 30000;
+  for (;;) {
+    try {
+      return await callWallet(
+        join(dataDir, "wallet", "wallet.sock"),
+        token,
+        "confirmSettlementDelivery",
+        { settlementUrl, orderId },
+      );
+    } catch (e) {
+      if (
+        Date.now() >= deadline ||
+        e.code !== "SETTLEMENT_REQUEST_REJECTED" ||
+        !String(e.message || "").includes("finalization cannot be confirmed")
+      )
+        throw e;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  }
+}
+export async function runOfficialPaidTest({
+  dataDir,
+  write = console.log,
+  ask = prompt,
+  read = readPrivate,
+  saveRecord = save,
+  archive = archiveCompleted,
+  lock = withClientRequestLock,
+  offer = readServiceOffer,
+  execute = run,
+  ack = confirmDelivery,
+  inspect = inspectInstalledBundle,
+  connect = loadRuntimeConnection,
+  tokenInfo = async (policy) => {
+    const rpc = new JsonRpcProvider(policy.registryRpcUrl, policy.chainId, {
+      staticNetwork: true,
+      batchMaxCount: 1,
+    });
+    try {
+      const token = new Contract(
+        policy.token,
+        [
+          "function decimals() view returns(uint8)",
+          "function symbol() view returns(string)",
+        ],
+        rpc,
+      );
+      const [decimals, symbol] = await Promise.all([
+        token.decimals(),
+        token.symbol(),
+      ]);
+      return { decimals: Number(decimals), symbol };
+    } finally {
+      rpc.destroy();
+    }
+  },
+} = {}) {
+  try {
+    dataDir ??= await resolveUserDataDir();
+    return await lock(
+      join(dataDir, "runtime", "official-test.lock"),
+      async () => {
+        const path = join(
+          dataDir,
+          "runtime",
+          `official-paid-test-${OFFICIAL_TEST_PACKAGE.version}.json`,
+        );
+        let record = await read(path);
+        const directory = join(
+          dataDir,
+          "runtime",
+          "skill-bundles",
+          `${OFFICIAL_TEST_PACKAGE.name}-${OFFICIAL_TEST_PACKAGE.version}-${OFFICIAL_TEST_PACKAGE.sha256}`,
+        );
+        const installed = await inspect(directory);
+        if (
+          installed.sha256 !== OFFICIAL_TEST_PACKAGE.sha256 ||
+          installed.locallyModified
+        )
+          throw Error(
+            "The installed official Skill differs from this User release. Run agentpay repair first.",
+          );
+        const connection = await connect({ dataDir });
+        if (
+          record &&
+          (record.version !== version ||
+            record.packageSha256 !== OFFICIAL_TEST_PACKAGE.sha256 ||
+            !/^[0-9a-f-]{36}$/.test(record.requestId || "") ||
+            JSON.stringify(record.input) !== JSON.stringify(input) ||
+            !record.terms ||
+            (record.needsRequote && record.result) ||
+            (record.result &&
+              (!/^0x[0-9a-f]{64}$/.test(record.result.orderId || "") ||
+                !/^0x[0-9a-f]{64}$/.test(record.result.outputHash || ""))))
+        )
+          throw Error(
+            "Saved official test record needs review. It was preserved; no new request was started.",
+          );
+        const completed = record?.acknowledged === true;
+        const previous = completed ? record : null;
+        if (completed) record = null;
+        if (!record || record.needsRequote) {
+          const current = await offer(connection, installed.service.reference);
+          if (
+            current?.commercialReady !== true ||
+            current.blockers?.length ||
+            !current.quote ||
+            BigInt(current.quote.maxUsageUnits || 0) < 1n
+          )
+            throw Error(
+              "Official service is not ready for a paid test. Check agentpay status and retry later.",
+            );
+          const terms = normalizeAcceptedTerms({
+            baseAmountAtomic: String(current.quote.baseAmountAtomic),
+            unitPriceAtomic: String(current.quote.unitPriceAtomic),
+            serviceWindowSeconds:
+              current.orderDeadlinePolicy?.serviceWindowSeconds,
+          });
+          const policy = await read(join(dataDir, "wallet", "policy.json"));
+          const ref = installed.service.reference;
+          if (
+            !policy ||
+            policy.chainId !== 31337 ||
+            policy.token?.toLowerCase() !==
+              current.quote.asset?.toLowerCase() ||
+            current.quote.network !== ref.profile.network ||
+            current.quote.providerId !== ref.profile.providerId ||
+            current.quote.skillId !== ref.skillId ||
+            current.quote.profileHash !== ref.profileHash
+          )
+            throw Error(
+              "Saved test Policy or service identity does not match the current offer on private Anvil.",
+            );
+          const { decimals, symbol } = await tokenInfo(policy);
+          const maximum =
+            BigInt(terms.baseAmountAtomic) + BigInt(terms.unitPriceAtomic);
+          if (maximum > BigInt(policy.maxAmount))
+            throw Error(
+              "Current quote exceeds this Wallet’s per-payment limit.",
+            );
+          write(
+            `\n> ${record ? "Review the updated test price" : "Test your payment connection"}\n\nUse the official test service to check payment and delivery.\n\nMaximum cost: ${formatUnits(maximum, Number(decimals))} ${symbol}\nService time limit: ${serviceTime(terms.serviceWindowSeconds)}\n\nAfter successful delivery, Wallet confirms receipt automatically.`,
+          );
+          if (previous)
+            write(
+              "Your previous test is complete. This will be a new paid test.",
+            );
+          if (
+            (await ask("Type 'confirm' to pay and test, or 'q' to cancel")) !==
+            "confirm"
+          ) {
+            write("Test cancelled. No new Order was started.");
+            return 0;
+          }
+          write("Preparing your test…");
+          if (record) {
+            record = { ...record, terms, needsRequote: false };
+            await saveRecord(path, record, true);
+          } else {
+            record = {
+              version,
+              packageSha256: OFFICIAL_TEST_PACKAGE.sha256,
+              requestId: randomUUID(),
+              input,
+              terms,
+            };
+            if (previous) {
+              await archive(dataDir, previous);
+              await saveRecord(path, record, true);
+            } else
+              try {
+                await saveRecord(path, record);
+              } catch (e) {
+                if (e.code !== "EEXIST") throw e;
+                record = await read(path);
+              }
+          }
+        } else
+          write(
+            "\n> Continue the unfinished payment test\nContinuing the original Order.",
+          );
+        if (
+          record.version !== version ||
+          record.packageSha256 !== OFFICIAL_TEST_PACKAGE.sha256 ||
+          JSON.stringify(record.input) !== JSON.stringify(input)
+        )
+          throw Error(
+            "Saved test record conflicts with this release. No request was started.",
+          );
+        normalizeAcceptedTerms(record.terms);
+        const script = join(directory, "random-skill", "scripts", "random.mjs");
+        const args = [
+          script,
+          "--invoke",
+          String(input.min),
+          String(input.max),
+          "--units",
+          "1",
+          "--request-id",
+          record.requestId,
+          "--accept-terms",
+          JSON.stringify(record.terms),
+        ];
+        const call = async () => {
+          let stdout;
+          try {
+            ({ stdout } = await execute(process.execPath, args, {
+              env: { ...process.env, AGENTPAY_USER_DATA_DIR: dataDir },
+              timeout: 330000,
+              maxBuffer: 2097152,
+            }));
+          } catch (error) {
+            let response;
+            try {
+              response = JSON.parse(error.stdout);
+            } catch {}
+            if (response?.error?.code === "QUOTE_TERMS_CHANGED") {
+              record = { ...record, needsRequote: true };
+              await saveRecord(path, record, true);
+              throw Error(
+                "Price or service time changed before Order creation. Run agentpay payment test again to review the new quote with the same request ID.",
+              );
+            }
+            throw error;
+          }
+          return resultIdentity(JSON.parse(stdout));
+        };
+        write("Waiting for the test result…");
+        const first = await call();
+        if (
+          record.result &&
+          (first.orderId !== record.result.orderId ||
+            first.outputHash !== record.result.outputHash)
+        )
+          throw Error(
+            "Retry returned different delivery. Preserve the Order for review.",
+          );
+        if (!record.result) {
+          record = { ...record, result: first };
+          await saveRecord(path, record, true);
+        }
+        write("Result received. Checking the saved result…");
+        const repeat = await call();
+        if (
+          repeat.orderId !== first.orderId ||
+          repeat.outputHash !== first.outputHash
+        )
+          throw Error(
+            "Repeated call returned different delivery. Preserve the Order for review.",
+          );
+        if (!record.acknowledged) {
+          write("Confirming receipt…");
+          await ack(dataDir, first.orderId);
+          record = { ...record, acknowledged: true };
+          await saveRecord(path, record, true);
+        }
+        write(
+          `Test complete. Payment and delivery are working.\nOrder ID: ${first.orderId}`,
+        );
+        return 0;
+      },
+    );
+  } catch (e) {
+    write(`Official test paused: ${e.message || "Unknown error"}`);
+    write(
+      "Retry agentpay payment test. Keep the original Order and local test record; do not start a replacement purchase.",
+    );
+    return 1;
+  }
+}

package/src/official-test-package.mjs

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MPL-2.0
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy was not distributed with this file, see https://mozilla.org/MPL/2.0/.
+import { createHash } from "node:crypto";
+
+// Release-reviewed ZIP bytes, not a value supplied by Market or deployment config.
+// Update only after reviewing the actual official package. See the release runbook.
+// This belongs to the official onboarding test, never generic Runtime routing.
+export const OFFICIAL_TEST_PACKAGE = Object.freeze({
+  name: "agentpay-random",
+  version: "1.2.0",
+  sha256: "aa366fc2e747b5b444786d542b0a412a505e58ea15252ac1a792b99079084146",
+});
+const mismatch = () =>
+  Object.assign(
+    new Error(
+      "The official test package does not match this User release. Keep your existing files and requests. Check for a reviewed User update; do not bypass the file check.",
+    ),
+    { code: "OFFICIAL_TEST_PACKAGE_MISMATCH" },
+  );
+
+export function verifyOfficialTestBytes(bytes) {
+  if (
+    createHash("sha256").update(bytes).digest("hex") !==
+    OFFICIAL_TEST_PACKAGE.sha256
+  )
+    throw mismatch();
+}
+export function verifyOfficialTestDigest(digest) {
+  if (digest !== OFFICIAL_TEST_PACKAGE.sha256) throw mismatch();
+}
+// A saved test may recover using its original locally verified material. This
+// never selects a replacement package or grants permission for another purchase.
+// The caller must still validate the checkpoint against local invocation history.
+export function verifyOfficialTestSelection(skill, checkpoint, savedDigest) {
+  if (!skill) return;
+  if (skill.bundle?.locallyModified) throw mismatch();
+  if (skill.bundle?.sha256 === OFFICIAL_TEST_PACKAGE.sha256) return;
+  if (checkpoint && skill.bundle?.sha256 === savedDigest) return;
+  throw mismatch();
+}