@c4roa0/agentpay-user 0.0.0-stage → 0.3.1

package/src/official-test-update.mjs

@@ -0,0 +1,162 @@
+import { deploymentFilePath, importSetupFiles } from "./installation-paths.mjs";
+// 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 { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import {
+  OFFICIAL_TEST_PACKAGE,
+  verifyOfficialTestBytes,
+  verifyOfficialTestDigest,
+} from "./official-test-package.mjs";
+import { marketDownloadUrl } from "./market-download-url.mjs";
+
+async function localJson(path) {
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const info = await handle.stat();
+    if (!info.isFile() || info.size > 65536)
+      throw Error("Invalid saved configuration");
+    return JSON.parse(await handle.readFile("utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  } finally {
+    await handle?.close();
+  }
+}
+function url(value) {
+  const u = new URL(value);
+  if (
+    u.username ||
+    u.password ||
+    u.hash ||
+    u.search ||
+    !(
+      u.protocol === "https:" ||
+      (u.protocol === "http:" &&
+        ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname))
+    )
+  )
+    throw Error("Invalid package source");
+  return u;
+}
+async function download(fetchImpl, address, max) {
+  const response = await fetchImpl(address, {
+    redirect: "error",
+    signal: AbortSignal.timeout(10000),
+  });
+  if (!response.ok || !response.body) throw Error("Market request failed");
+  let length = 0;
+  const chunks = [];
+  for await (const chunk of response.body) {
+    length += chunk.length;
+    if (length > max) throw Error("Market response too large");
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+export async function prepareOfficialTestUpdate({
+  userDir,
+  dataDir,
+  write = console.log,
+  fetchImpl = fetch,
+  readJson = localJson,
+  install,
+} = {}) {
+  write("\n> Official test Skill");
+  try {
+    let source;
+    for (const name of ["anvil-onboarding.json", "user-deployment.json"]) {
+      const saved = await readJson(await deploymentFilePath(dataDir, userDir, name));
+      if (saved?.marketBundleMetadataUrl) {
+        source = saved.marketBundleMetadataUrl;
+        break;
+      }
+    }
+    if (!source) {
+      const saved = await readJson(join(dataDir, "market-connection.json"));
+      if (saved?.marketOrigin) {
+        const origin = url(saved.marketOrigin);
+        if (origin.pathname !== "/") throw Error("Invalid Market origin");
+        const deployment = JSON.parse(
+          (
+            await download(
+              fetchImpl,
+              new URL("/market/web/onboarding/user-config", origin),
+              16384,
+            )
+          ).toString("utf8"),
+        );
+        source = deployment.marketBundleMetadataUrl;
+      }
+    }
+    if (!source) {
+      write(
+        "Not checked: no saved Market test source. Continue agentpay setup when ready.",
+      );
+      return { status: "unconfigured" };
+    }
+    const metadataUrl = url(source);
+    if (
+      !/^\/(?:market\/)?skills\/bundles\/[^/]+\/metadata$/.test(
+        metadataUrl.pathname,
+      )
+    )
+      throw Error("Invalid package metadata path");
+    const body = JSON.parse(
+      (await download(fetchImpl, metadataUrl, 65536)).toString("utf8"),
+    );
+    if (body.ok !== true) throw Error("Metadata unavailable");
+    verifyOfficialTestDigest(body.result?.sha256);
+    const downloadUrl = marketDownloadUrl(
+      metadataUrl,
+      body.result.marketServiceId,
+    );
+    const bytes = await download(fetchImpl, downloadUrl, 2097152);
+    verifyOfficialTestBytes(bytes);
+    // Load package dependencies only after the software dependency update completed.
+    const { parseSkillBundle, installSkillBundle } = await import(
+      "./skill-bundle.mjs"
+    );
+    const bundle = parseSkillBundle(bytes);
+    if (
+      bundle.manifest.packageName !== OFFICIAL_TEST_PACKAGE.name ||
+      bundle.manifest.packageVersion !== OFFICIAL_TEST_PACKAGE.version
+    )
+      throw Error("Official package identity mismatch");
+    const saved = await (install || installSkillBundle)({
+      dataDir,
+      bytes,
+      source: metadataUrl.href,
+    });
+    if (saved.locallyModified) {
+      write(
+        "Official ZIP verified, but its installed files have local edits. Existing files were kept; review them before testing.",
+      );
+      return { status: "local_edits" };
+    }
+    write(
+      `Version ${OFFICIAL_TEST_PACKAGE.version} verified against User's built-in SHA-256 and saved locally.`,
+    );
+    write(
+      "Original test records and package selection were kept. No test or payment was started.",
+    );
+    return { status: "ready", directory: saved.directory };
+  } catch (error) {
+    if (error.code === "OFFICIAL_TEST_PACKAGE_MISMATCH")
+      write(
+        "Not updated: the published ZIP does not match this User release. Check for a reviewed User update; do not bypass the file check.",
+      );
+    else
+      write(
+        "Could not prepare the official test Skill. Check your Market connection and retry agentpay repair.",
+      );
+    write(
+      "The software update is kept; existing test files and Orders were not replaced.",
+    );
+    return { status: "unavailable" };
+  }
+}

package/src/order-cancellation.mjs

@@ -0,0 +1,241 @@
+// 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 { isUnpaidExpiry } from "./order-closure.mjs";
+import { randomBytes, createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, link, unlink } from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import { callWallet, readCapability } from "@c4roa0/agentpay-wallet";
+import { readPrivateFile } from "./runtime-client.mjs";
+import { readSettlementResult } from "./settlement-response.mjs";
+const B32 = /^0x[0-9a-f]{64}$/;
+const fail = (code) => Object.assign(Error(code), { code });
+export function cancellationSettlementUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw fail("INVALID_SETTLEMENT_URL");
+  }
+  if (
+    (url.protocol !== "https:" &&
+      !(
+        url.protocol === "http:" &&
+        ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)
+      )) ||
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash
+  )
+    throw fail("INVALID_SETTLEMENT_URL");
+  return url.href.replace(/\/$/, "");
+}
+async function sync(path) {
+  const handle = await open(
+    path,
+    constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW,
+  );
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function privateDirectory(path) {
+  await mkdir(path, { recursive: true, mode: 0o700 });
+  const h = await open(
+    path,
+    constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW,
+  );
+  try {
+    const s = await h.stat();
+    if (s.uid !== process.getuid() || s.mode & 0o077)
+      throw fail("LOCAL_STATE_UNSAFE");
+  } finally {
+    await h.close();
+  }
+  await sync(dirname(path));
+}
+async function context(input, walletCall) {
+  if (
+    !input ||
+    Object.keys(input).sort().join(",") !== "dataDir,orderId,settlementUrl"
+  )
+    throw fail("INVALID_CANCEL_INPUT");
+  const dataDir = resolve(input.dataDir),
+    orderId = String(input.orderId).toLowerCase();
+  if (!B32.test(orderId)) throw fail("INVALID_ORDER_ID");
+  const settlementUrl = cancellationSettlementUrl(input.settlementUrl);
+  const call =
+    walletCall ||
+    (async (method, params = {}) =>
+      callWallet(
+        join(dataDir, "wallet/wallet.sock"),
+        await readCapability(join(dataDir, "wallet"), "agent"),
+        method,
+        params,
+      ));
+  const status = await call("status");
+  if (!status.bound || !B32.test(status.policyId || ""))
+    throw fail("POLICY_UNBOUND");
+  return {
+    dataDir,
+    orderId,
+    settlementUrl,
+    policyId: status.policyId,
+    call,
+    path: join(
+      dataDir,
+      "runtime/order-cancellations",
+      createHash("sha256").update(orderId).digest("hex") + ".json",
+    ),
+  };
+}
+async function readIntent(ctx) {
+  let intent;
+  try {
+    intent = JSON.parse(await readPrivateFile(ctx.path));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw fail("CANCELLATION_STATE_INVALID");
+  }
+  if (
+    !intent ||
+    Object.keys(intent).sort().join(",") !==
+      "cancellationId,createdAtMs,orderId,policyId,settlementUrl,version" ||
+    intent.version !== "agentpay.user-order-cancellation.v1" ||
+    !B32.test(intent.cancellationId || "") ||
+    intent.orderId !== ctx.orderId ||
+    intent.policyId !== ctx.policyId ||
+    intent.settlementUrl !== ctx.settlementUrl ||
+    !Number.isSafeInteger(intent.createdAtMs) ||
+    intent.createdAtMs < 0
+  )
+    throw fail("CANCELLATION_STATE_CONFLICT");
+  return intent;
+}
+async function ensureIntent(ctx) {
+  const existing = await readIntent(ctx);
+  if (existing) return existing;
+  await privateDirectory(ctx.dataDir);
+  await privateDirectory(join(ctx.dataDir, "runtime"));
+  await privateDirectory(dirname(ctx.path));
+  const value = {
+    version: "agentpay.user-order-cancellation.v1",
+    orderId: ctx.orderId,
+    policyId: ctx.policyId,
+    settlementUrl: ctx.settlementUrl,
+    cancellationId: "0x" + randomBytes(32).toString("hex"),
+    createdAtMs: Date.now(),
+  };
+  const temp = ctx.path + "." + randomBytes(12).toString("hex") + ".tmp";
+  const h = await open(temp, "wx", 0o600);
+  try {
+    try {
+      await h.writeFile(JSON.stringify(value) + "\n");
+      await h.sync();
+    } finally {
+      await h.close();
+    }
+    try {
+      await link(temp, ctx.path);
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+    }
+    await sync(dirname(ctx.path));
+  } finally {
+    await unlink(temp).catch((e) => {
+      if (e.code !== "ENOENT") throw e;
+    });
+  }
+  return readIntent(ctx);
+}
+async function readOrder(ctx, intent) {
+  const result = readSettlementResult(
+    await ctx.call("readSettlementOrder", {
+      settlementUrl: ctx.settlementUrl,
+      orderId: ctx.orderId,
+    }),
+  );
+  if (result.order?.orderId !== ctx.orderId)
+    throw fail("CANCELLATION_RESPONSE_INVALID");
+  const state = result.closure?.state,
+    terminal = state === "cancelled" || state === "refunded";
+  return {
+    orderId: ctx.orderId,
+    cancellationId: intent?.cancellationId || null,
+    orderStatus: result.order.orderStatus,
+    vaultState: result.order.vaultState,
+    waiting: result.waiting || null,
+    closure: result.closure || null,
+    message: isUnpaidExpiry(result)
+      ? "Order expired without payment. No service result is expected."
+      : terminal
+        ? state === "refunded"
+          ? "Principal refunded; cumulative Policy spend is not restored."
+          : "Order cancelled."
+        : state
+          ? "Closure is pending. Check this same Order again."
+          : "No confirmed cancellation. Check this same Order before retrying.",
+  };
+}
+export async function cancelOrder(input, { walletCall } = {}) {
+  const ctx = await context(input, walletCall),
+    intent = await ensureIntent(ctx);
+  // The immutable identity is durable before the first HTTP request. Response loss
+  // retries the same cancellation; no invocation/Commitment or payment is created.
+  const response = readSettlementResult(
+    await ctx.call("cancelSettlementOrder", {
+      settlementUrl: ctx.settlementUrl,
+      orderId: ctx.orderId,
+      cancellationId: intent.cancellationId,
+    }),
+  );
+  if (
+    response.orderId !== ctx.orderId ||
+    !response.closure ||
+    typeof response.duplicate !== "boolean"
+  )
+    throw fail("CANCELLATION_RESPONSE_INVALID");
+  return readOrder(ctx, intent);
+}
+export async function cancellationStatus(input, { walletCall } = {}) {
+  const ctx = await context(input, walletCall);
+  return readOrder(ctx, await readIntent(ctx));
+}
+
+// Resolve only existing Runtime history; never prepare a replacement Order here.
+export async function cancellationOrderForRequest({ dataDir, requestId }) {
+  if (
+    typeof requestId !== "string" ||
+    !/^[A-Za-z0-9._:-]{8,128}$/.test(requestId)
+  )
+    throw fail("INVALID_REQUEST_ID");
+  const document = JSON.parse(
+    await readPrivateFile(
+      join(resolve(dataDir), "runtime/invocations.json"),
+      16 * 1048576,
+    ),
+  );
+  const id =
+    "0x" +
+    createHash("sha256")
+      .update("agentpay.user-invocation.v1:" + requestId)
+      .digest("hex");
+  const entry =
+    document?.version === "agentpay.user-invocations.v1"
+      ? document.invocations?.[id]
+      : null;
+  if (
+    !entry ||
+    entry.invocationId !== id ||
+    entry.routingVersion !== "agentpay.runtime-call.v1" ||
+    !B32.test(entry.requestHash || "")
+  )
+    throw fail("INVOCATION_NOT_FOUND");
+  if (entry.orderId === null) throw fail("ORDER_NOT_CREATED");
+  if (!B32.test(entry.orderId || "")) throw fail("CANCELLATION_STATE_INVALID");
+  return entry.orderId;
+}

package/src/order-closure.mjs

@@ -0,0 +1,42 @@
+// 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/.
+// A business expiry is not a claim that the old Vault was cancelled on chain.
+export function isUnpaidExpiry(result) {
+  return (
+    result?.preparationState === "expired" &&
+    result?.closure?.state === "cancelled" &&
+    result.closure.reason === "payment_timeout" &&
+    result.closure.transactionHash === null &&
+    result.order?.vaultState === "Created" &&
+    result.order?.serviceState === "closed"
+  );
+}
+// Closure is independent of the frozen participant Order status enum.
+export function assertOrderCanContinue(result) {
+  const state = result?.closure?.state,
+    vault = result?.order?.vaultState;
+  if (isUnpaidExpiry(result))
+    throw coded(
+      "ORDER_EXPIRED",
+      "This Order expired without payment. No service result is expected. Keep the original request; it will not be paid again automatically.",
+    );
+  if (state === "cancelled" || vault === "Cancelled")
+    throw coded(
+      "ORDER_CANCELLED",
+      "This Order was cancelled. Preserve its request and payment history.",
+    );
+  if (state === "refunded" || vault === "Refunded")
+    throw coded(
+      "ORDER_REFUNDED",
+      "This Order was refunded. Its cumulative Policy spend is not restored.",
+    );
+  if (state)
+    throw coded(
+      "ORDER_CLOSING",
+      "This Order is closing. Query the same Order; do not submit another payment or service request.",
+    );
+}
+function coded(code, message) {
+  return Object.assign(Error(message), { code });
+}

package/src/order-list-panel.mjs

@@ -0,0 +1,110 @@
+// 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 { localOrderSummary } from "./order-review.mjs";
+
+// Rendering only: saved observations are not fresh financial verification.
+export function renderOrderList(
+  entries,
+  observations,
+  notes,
+  { color = false, columns = 80 } = {},
+) {
+  const width = Math.max(
+    48,
+    Math.min(72, Number.isFinite(columns) ? Math.floor(columns) : 80),
+  );
+  const paint = (text, style) =>
+    color ? `\x1b[${style}m${text}\x1b[0m` : text;
+  const lines = [],
+    rule = "─".repeat(width);
+  function text(value, { indent = "  ", style = null } = {}) {
+    let line = indent;
+    for (const word of value.split(/\s+/)) {
+      if (line.trim() && line.length + 1 + word.length > width) {
+        lines.push(style ? paint(line, style) : line);
+        line = indent;
+      }
+      line += (line.trim() ? " " : "") + word;
+    }
+    lines.push(style ? paint(line, style) : line);
+  }
+  lines.push(
+    "",
+    paint(rule, "2"),
+    paint("> Local Orders", "1"),
+    paint(rule, "2"),
+  );
+  text(`${entries.length} saved · latest first`, { style: "2" });
+  if (!entries.length) text("No saved Orders or requests.");
+  entries.forEach((e, index) => {
+    const summary = localOrderSummary(
+      e,
+      observations[e.invocationId],
+      notes[e.invocationId],
+    );
+    const id = e.orderId || e.invocationId;
+    let length = 12;
+    while (
+      length < 66 &&
+      entries.filter(
+        (v) =>
+          v.invocationId.startsWith(id.slice(0, length)) ||
+          v.orderId?.startsWith(id.slice(0, length)),
+      ).length > 1
+    )
+      length++;
+    const selector = id.slice(0, length);
+    const style =
+      summary.marker === "ARCHIVED"
+        ? "2"
+        : summary.marker === "OK"
+          ? "1;32"
+          : "1;33";
+    lines.push("", paint(rule, "2"));
+    text(
+      `${index + 1}. [${summary.marker}] ${summary.state}${summary.localResultUnavailable ? " · Local result unavailable" : ""}`,
+      { style },
+    );
+    const date = Number.isSafeInteger(e.createdAtMs)
+      ? new Date(e.createdAtMs).toLocaleString()
+      : "Date not recorded";
+    text(date, { style: "2" });
+    if (Number.isSafeInteger(summary.checkedAtMs))
+      text("Last check: " + new Date(summary.checkedAtMs).toLocaleString(), {
+        style: "2",
+      });
+    text(
+      `${e.orderId ? "Order" : "Request"}  ${id.slice(0, 12)}…${id.slice(-6)}`,
+      { style: "2" },
+    );
+    if (summary.warning) {
+      lines.push("");
+      text(summary.marker === "ARCHIVED" ? "Saved note" : "Warning", { style });
+      text(summary.warning);
+    }
+    if (summary.changed)
+      text("Changed since archiving. Review this record again.", {
+        style: "1;33",
+      });
+    lines.push("");
+    text("View details", { style: "1" });
+    text(`agentpay orders details ${selector}`, { style: "36" });
+    text(
+      notes[e.invocationId]?.archived
+        ? "Restore reminder"
+        : "Archive after review",
+      { style: "2" },
+    );
+    text(
+      `agentpay orders ${notes[e.invocationId]?.archived ? "unarchive" : "archive"} ${selector}`,
+      { style: "36" },
+    );
+  });
+  lines.push("", paint(rule, "2"));
+  text("Saved checks only. Full IDs and review notes are in details.", {
+    style: "2",
+  });
+  lines.push("");
+  return lines.join("\n");
+}