@c4roa0/agentpay-user 0.0.0-stage → 0.3.0

package/src/order-support.mjs

@@ -0,0 +1,365 @@
+// 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 { showOrderStatus } from "./order-status-panel.mjs";
+import { renderOrderList } from "./order-list-panel.mjs";
+import { createInterface } from "node:readline/promises";
+import {
+  localOrderReviews,
+  readPrivateJson,
+  findLocalOrder,
+  localReviewDetails,
+  recordFingerprint,
+  observationKey,
+} from "./order-review.mjs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { createConnection } from "node:net";
+import { open } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolveUserDataDir } from "./local-data-directory.mjs";
+import { readServiceSettings } from "./local-services.mjs";
+import { createInvocationStore } from "./invocation-store.mjs";
+import { invocationResults } from "./invocation-result.mjs";
+import {
+  parseServiceReference,
+  providerOutput,
+  normalizeRuntimeResult,
+} from "./service-reference.mjs";
+import { fetchJsonWithTimeout } from "./transport.mjs";
+import { readSettlementResult } from "./settlement-response.mjs";
+async function privateText(path) {
+  const f = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const s = await f.stat();
+    if (
+      !s.isFile() ||
+      s.uid !== process.getuid() ||
+      s.mode & 0o077 ||
+      s.size > 65536
+    )
+      throw Error("Unsafe local credential");
+    return await f.readFile("utf8");
+  } finally {
+    await f.close();
+  }
+}
+async function wallet(dataDir, method, params) {
+  const token = (await privateText(join(dataDir, "wallet/agent.token"))).trim();
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(join(dataDir, "wallet/wallet.sock"));
+    let text = "",
+      done = false;
+    const finish = (e, v) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.destroy();
+      e ? reject(e) : resolve(v);
+    };
+    const timer = setTimeout(
+      () => finish(Error("Wallet did not respond. Run agentpay status.")),
+      40000,
+    );
+    socket.setEncoding("utf8");
+    socket.once("error", (e) => finish(e));
+    socket.once("connect", () =>
+      socket.write(
+        JSON.stringify({
+          id: randomBytes(8).toString("hex"),
+          token,
+          method,
+          params,
+        }) + "\n",
+      ),
+    );
+    socket.on("data", (part) => {
+      text += part;
+      if (text.length > 8 * 1048576) finish(Error("Wallet response too large"));
+    });
+    socket.once("end", () => {
+      try {
+        const result = JSON.parse(text);
+        if (!result.ok)
+          throw Object.assign(
+            Error(result.error?.message || "Wallet rejected this operation"),
+            { code: result.error?.code },
+          );
+        finish(null, result.result);
+      } catch (e) {
+        finish(e);
+      }
+    });
+  });
+}
+async function askTerminal(message) {
+  if (!process.stdin.isTTY)
+    throw Error("Run this command in an interactive terminal.");
+  const r = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await r.question(message + "\n> ");
+  } finally {
+    r.close();
+  }
+}
+export async function runOrderSupport(
+  args,
+  {
+    write = console.log,
+    dataDir: chosen,
+    ask = askTerminal,
+    color = Boolean(process.stdout.isTTY) &&
+      process.env.TERM !== "dumb" &&
+      !Object.hasOwn(process.env, "NO_COLOR"),
+    columns = process.stdout.columns || 80,
+  } = {},
+) {
+  try {
+    const dataDir = chosen || (await resolveUserDataDir()),
+      path = join(dataDir, "runtime/invocations.json");
+    const store = createInvocationStore(path),
+      inventory = await store.inventory();
+    const reviews = localOrderReviews(path),
+      notes = (await reviews.load()).records;
+    const observations =
+      (await readPrivateJson(path + ".recovery.json", 16 * 1048576))
+        ?.observations || {};
+    if (args.length === 0) {
+      const entries = Object.values(inventory).sort(
+        (a, b) => (b.createdAtMs || 0) - (a.createdAtMs || 0),
+      );
+      write(renderOrderList(entries, observations, notes, { color, columns }));
+      return 0;
+    }
+    const [selector, action = "details"] = args;
+    if (
+      ![
+        "details",
+        "archive",
+        "unarchive",
+        "status",
+        "case",
+        "retrieve",
+      ].includes(action) ||
+      args.length > 2
+    ) {
+      write(
+        "Usage: agentpay orders details|status|archive|unarchive|case|retrieve ID",
+      );
+      return 2;
+    }
+    const entry = findLocalOrder(inventory, selector),
+      orderId = entry.orderId,
+      observation = observations[entry.invocationId],
+      review = notes[entry.invocationId];
+    if (["details", "archive", "unarchive"].includes(action)) {
+      write(
+        localReviewDetails(entry, observation, review, {
+          selector,
+          color,
+          columns,
+        }),
+      );
+      if (action === "details") return 0;
+      if (action === "unarchive") {
+        await reviews.change(entry, observation, { archive: false, note: "" });
+        write(
+          "Unarchived. Original records and payment permissions are unchanged.",
+        );
+        return 0;
+      }
+      write(
+        "Archive hides this checked warning, not the record. It does not cancel an Order or stop work already in progress.",
+      );
+      const note = (
+        await ask(
+          "Review note (up to 500 characters; no passwords or private content). Type 'q' to return.",
+        )
+      ).trim();
+      if (note === "q") return 0;
+      if (!note || note.length > 500 || /[\u0000-\u001f\u007f]/.test(note))
+        throw Error("Enter a short, single-line review note.");
+      if (
+        (
+          await ask(
+            "Type 'confirm' to archive locally, or anything else to return.",
+          )
+        ).trim() !== "confirm"
+      )
+        return 0;
+      const fresh = (await store.inventory())[entry.invocationId],
+        latest = (await readPrivateJson(path + ".recovery.json", 16 * 1048576))
+          ?.observations?.[entry.invocationId];
+      if (
+        !fresh ||
+        recordFingerprint(fresh) !== recordFingerprint(entry) ||
+        observationKey(latest) !== observationKey(observation)
+      )
+        throw Error(
+          "The record changed while you were reviewing it. Open details again before archiving.",
+        );
+      await reviews.change(entry, observation, { archive: true, note });
+      write(
+        "Archived locally. Same-request execution is blocked until you unarchive it. Status updates on the next local check.",
+      );
+      return 0;
+    }
+    if (action === "case") {
+      if (!orderId)
+        throw Error(
+          "No Order ID is saved. Open local details before requesting support.",
+        );
+      write(
+        `Connect this Wallet to your Market account:\n  agentpay market connect\nThen open Market → Account → My Orders and choose Order ${orderId}.\nThe connection covers this Wallet authorization; no one-Order access code is needed.`,
+      );
+      return 0;
+    }
+    if (action === "status")
+      return showOrderStatus({
+        entry,
+        observation,
+        review,
+        selector,
+        write,
+        read: async () => {
+          const settings = await readServiceSettings(dataDir);
+          const w = await wallet(dataDir, "status", {}),
+            c = entry.paymentPayload?.payload?.commitment;
+          const recoveryScope =
+            entry.recoveryScope ||
+            (c?.policyId && w.recoveryScope
+              ? {
+                  ...w.recoveryScope,
+                  policyId: c.policyId,
+                  safe: c.safe,
+                  network: entry.paymentPayload.accepted?.network,
+                }
+              : null);
+          const result = readSettlementResult(
+            await wallet(dataDir, "readSettlementOrder", {
+              settlementUrl: settings.settlementUrl,
+              ...(orderId
+                ? { orderId }
+                : { orderRequestId: entry.orderRequestId }),
+              ...(recoveryScope ? { recoveryScope } : {}),
+            }),
+          );
+          return result;
+        },
+      });
+    const settings = await readServiceSettings(dataDir),
+      params = { settlementUrl: settings.settlementUrl, orderId };
+    if (!orderId)
+      throw Error(
+        "No Order ID is saved. Open local details; do not start a replacement purchase.",
+      );
+    const response = await wallet(dataDir, "requestSettlementResult", {
+        ...params,
+        operationId: "0x" + randomBytes(32).toString("hex"),
+      }),
+      permission = response?.result;
+    if (
+      !response?.ok ||
+      permission?.orderId !== orderId ||
+      permission.requestHash !== entry.requestHash
+    )
+      throw Error("Result retrieval identity mismatch");
+    if (entry.routingVersion === "agentpay.runtime-call.v1") {
+      const binding = JSON.parse(entry.serviceBinding),
+        reference = parseServiceReference(binding.reference);
+      if (permission.endpoint !== reference.profile.paymentEndpoint)
+        throw Error("Retrieval endpoint differs from the original service");
+    }
+    if (typeof permission.endpoint !== "string" || !permission.endpoint)
+      throw Error(
+        "Original Provider endpoint is unavailable. Contact the Provider with this Order ID; no replacement purchase was started.",
+      );
+    const endpoint = new URL(permission.endpoint);
+    if (
+      !["http:", "https:"].includes(endpoint.protocol) ||
+      endpoint.username ||
+      endpoint.password ||
+      endpoint.search ||
+      endpoint.hash
+    )
+      throw Error("Provider retrieval endpoint is unsafe");
+    const fetched = await fetchJsonWithTimeout(
+      endpoint,
+      {
+        method: "POST",
+        headers: {
+          authorization:
+            "AgentPayResult " +
+            Buffer.from(JSON.stringify(permission)).toString("base64url"),
+        },
+      },
+      35000,
+    );
+    if (!fetched.response.ok || !fetched.result?.ok)
+      throw Error(
+        fetched.result?.error?.message ||
+          "Original result is unavailable; open a case before its deadline.",
+      );
+    const status = readSettlementResult(
+        await wallet(dataDir, "readSettlementOrder", params),
+      ),
+      evidence = status.deliveryEvidence;
+    const output = fetched.result.result;
+    if (
+      !evidence ||
+      output?.orderId !== orderId ||
+      output.requestHash !== entry.requestHash ||
+      output.outputHash !== evidence.outputHash ||
+      String(output.usageUnits) !== String(evidence.usageUnits)
+    )
+      throw Error("Recovered result does not match original delivery evidence");
+    if (entry.routingVersion !== "agentpay.runtime-call.v1")
+      throw Error(
+        "Original result was returned, but this older request needs a reviewed format adapter. No replacement purchase was made.",
+      );
+    const binding = JSON.parse(entry.serviceBinding),
+      reference = parseServiceReference(binding.reference),
+      context = {
+        reference,
+        skillId: reference.skillId,
+        profileHash: reference.profileHash,
+        requestedMaxUsageUnits: binding.requestedMaxUsageUnits,
+      };
+    const result = providerOutput(
+      fetched.result,
+      context,
+      null,
+      orderId,
+      entry.requestHash,
+    );
+    const restored = normalizeRuntimeResult(
+      {
+        version: "agentpay.runtime-result.v1",
+        orderId,
+        requestHash: entry.requestHash,
+        service: { skillId: context.skillId, profileHash: context.profileHash },
+        output: result.output,
+        outputHash: result.outputHash,
+        usageUnits: result.usageUnits,
+        deliveryEvidenceVerified: true,
+        finalization: status.finalization,
+        deadlines: status.deadlines,
+      },
+      context,
+      entry.requestHash,
+      orderId,
+    );
+    await invocationResults(path).save(entry, restored);
+    write(
+      "Original result restored. Resume the original Skill request to read it. No new service execution or payment was requested.",
+    );
+    return 0;
+  } catch (e) {
+    write(
+      ["WALLET_LOCKED", "LOCKED"].includes(e.code)
+        ? "Wallet is locked. Run agentpay wallet unlock, then repeat this command."
+        : String(e.message || e),
+    );
+    return 1;
+  }
+}

package/src/owner-approval-server.mjs

@@ -0,0 +1,332 @@
+// Temporary loopback approval UI for a fixed public plan, not a generic signer.
+// Exported pages must exclude credentials and still verify chain execution.
+// 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 { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { readFile, mkdtemp, writeFile, mkdir, open } from "node:fs/promises";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { Interface, isAddress, isHexString } from "ethers";
+
+export function validateOwnerPlan({ source, calls }) {
+  if (
+    !Number.isSafeInteger(source.chainId) ||
+    source.chainId < 1 ||
+    !isAddress(source.safe) ||
+    !isAddress(source.module) ||
+    !Array.isArray(calls) ||
+    !calls.length ||
+    calls.length > 4
+  )
+    throw Error("Invalid owner plan.");
+  if (source.previousModule && !isAddress(source.previousModule))
+    throw Error("Invalid previous Module.");
+  const module = new Interface([
+    "function createPolicy(bytes32,address,address,address,address,uint256,uint256,uint64,uint64)",
+    "function revokePolicy(bytes32)",
+  ]);
+  const safe = new Interface(["function enableModule(address)"]);
+  for (const c of calls) {
+    if (c.value !== "0" || c.operation !== 0 || !isHexString(c.data))
+      throw Error("Unsupported owner operation.");
+    if (c.to.toLowerCase() === source.safe.toLowerCase()) {
+      if (
+        safe.decodeFunctionData("enableModule", c.data)[0].toLowerCase() !==
+        source.module.toLowerCase()
+      )
+        throw Error("Module mismatch.");
+    } else if (
+      c.to.toLowerCase() === source.module.toLowerCase() ||
+      (source.previousModule &&
+        isAddress(source.previousModule) &&
+        c.to.toLowerCase() === source.previousModule.toLowerCase())
+    ) {
+      const parsed = module.parseTransaction({ data: c.data });
+      if (
+        c.to.toLowerCase() !== source.module.toLowerCase() &&
+        parsed?.name !== "revokePolicy"
+      )
+        throw Error("Previous Module only allows revocation.");
+      if (!["createPolicy", "revokePolicy"].includes(parsed?.name))
+        throw Error("Unsupported Module operation.");
+    } else throw Error("Unsupported owner target.");
+  }
+  return {
+    version: 1,
+    chainId: source.chainId,
+    safe: source.safe,
+    module: source.module,
+    ...(source.previousModule ? { previousModule: source.previousModule } : {}),
+    calls: calls.map((c) => ({
+      purpose: c.purpose,
+      to: c.to,
+      value: "0",
+      operation: 0,
+      data: c.data,
+    })),
+  };
+}
+export async function ownerAssets(input) {
+  const plan = validateOwnerPlan(input);
+  const assets = new Map([
+    [
+      "index.html",
+      await readFile(new URL("../web/owner-approval.html", import.meta.url)),
+    ],
+    [
+      "owner-approval.js",
+      await readFile(new URL("../web/owner-approval.js", import.meta.url)),
+    ],
+    [
+      "ethers.js",
+      await readFile(
+        new URL(
+          "../node_modules/ethers/dist/ethers.umd.min.js",
+          import.meta.url,
+        ),
+      ),
+    ],
+    [
+      "plan.js",
+      Buffer.from(
+        "window.agentpayOwnerPlan=" +
+          JSON.stringify(plan).replace(/</g, "\\u003c") +
+          ";",
+      ),
+    ],
+  ]);
+  assets.operationCount = plan.calls.length;
+  return assets;
+}
+export function createOwnerServer(assets, { saveJournal } = {}) {
+  const prefix = "/" + randomBytes(24).toString("hex") + "/";
+  const server = createServer(async (req, res) => {
+    const host = "127.0.0.1:" + server.address().port;
+    res.setHeader("cache-control", "no-store");
+    res.setHeader("x-content-type-options", "nosniff");
+    res.setHeader(
+      "content-security-policy",
+      "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'",
+    );
+    if (
+      req.url === prefix + "journal" &&
+      req.method === "POST" &&
+      saveJournal
+    ) {
+      if (
+        req.headers.host !== host ||
+        req.headers.origin !== "http://" + host ||
+        req.headers["content-type"] !== "application/json"
+      ) {
+        res.writeHead(403);
+        return res.end();
+      }
+      try {
+        let raw = "";
+        for await (const chunk of req) {
+          raw += chunk;
+          if (raw.length > 2048) throw Error();
+        }
+        const value = JSON.parse(raw);
+        if (value !== null) {
+          const count = assets.operationCount;
+          if (
+            value.callIndex !== undefined &&
+            (!Number.isInteger(value.callIndex) ||
+              value.callIndex < 0 ||
+              value.callIndex >= count)
+          )
+            throw Error();
+          if (value.kind === "intent") {
+            if (!Number.isInteger(value.callIndex)) throw Error();
+          } else if (
+            !["approve", "execute"].includes(value.kind) ||
+            !/^0x[0-9a-fA-F]{64}$/.test(value.transactionHash) ||
+            (value.kind === "execute" &&
+              !/^0x[0-9a-fA-F]{64}$/.test(value.safeHash))
+          )
+            throw Error();
+        }
+        await saveJournal(value);
+        res.end("ok");
+      } catch {
+        res.writeHead(400);
+        res.end();
+      }
+      return;
+    }
+    if (
+      req.headers.host !== host ||
+      req.headers["sec-fetch-site"] === "cross-site" ||
+      req.method !== "GET" ||
+      !req.url.startsWith(prefix)
+    ) {
+      res.writeHead(403);
+      return res.end("Open the authorization address shown in your terminal.");
+    }
+    const name = req.url.slice(prefix.length) || "index.html",
+      body = assets.get(name);
+    if (!body) {
+      res.writeHead(404);
+      return res.end();
+    }
+    res.setHeader(
+      "content-type",
+      name.endsWith(".js")
+        ? "application/javascript"
+        : "text/html; charset=utf-8",
+    );
+    res.end(body);
+  });
+  return { server, prefix };
+}
+export async function exportOwnerPage(assets, dataDir) {
+  const parent = join(dataDir, "runtime");
+  // The caller's private data directory is established by normal User setup.
+  await mkdir(parent, { recursive: true, mode: 0o700 });
+  const folder = await mkdtemp(join(parent, "safe-authorization-"));
+  for (const [name, original] of assets) {
+    const body =
+      name === "plan.js"
+        ? Buffer.from(
+            original
+              .toString()
+              .replace("window.agentpayJournalServer=true;", ""),
+          )
+        : original;
+    await writeFile(join(folder, name), body, { mode: 0o600, flag: "wx" });
+  }
+  const script = `import {createServer} from 'node:http';\nimport {readFile} from 'node:fs/promises';\nconst names=new Set(['index.html','plan.js','ethers.js','owner-approval.js']);\nconst s=createServer(async(q,r)=>{const host='127.0.0.1:'+s.address().port;const n=q.url==='/'?'index.html':q.url.slice(1);if(q.method!=='GET'||q.headers.host!==host||q.headers['sec-fetch-site']==='cross-site'||!names.has(n)){r.writeHead(403);return r.end();}r.setHeader('cache-control','no-store');r.setHeader('x-content-type-options','nosniff');r.setHeader('content-type',n.endsWith('.js')?'application/javascript':'text/html; charset=utf-8');r.end(await readFile(new URL(n,import.meta.url)));});\ns.listen(0,'127.0.0.1',()=>console.log('Open http://127.0.0.1:'+s.address().port));\n`;
+  await writeFile(join(folder, "serve.mjs"), script, {
+    mode: 0o600,
+    flag: "wx",
+  });
+  return folder;
+}
+export function tryBrowser(
+  url,
+  { env = process.env, platform = process.platform } = {},
+) {
+  const command =
+    platform === "darwin"
+      ? "open"
+      : env.DISPLAY || env.WAYLAND_DISPLAY
+        ? "xdg-open"
+        : null;
+  if (!command) return false;
+  try {
+    const child = spawn(command, [url], { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+export async function approveOwnerOperations({
+  source,
+  calls,
+  dataDir,
+  ask,
+  write = console.log,
+  check,
+  onSubmitted,
+  openBrowser = tryBrowser,
+}) {
+  const assets = await ownerAssets({ source, calls });
+  const digest = createHash("sha256")
+    .update(assets.get("plan.js"))
+    .digest("hex");
+  const folder = join(dataDir, "runtime");
+  await mkdir(folder, { recursive: true, mode: 0o700 });
+  const journalPath = join(folder, "owner-operation-" + digest + ".json");
+  let journal = null,
+    h;
+  try {
+    h = await open(journalPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const st = await h.stat();
+    if (
+      !st.isFile() ||
+      st.uid !== process.getuid() ||
+      st.mode & 0o077 ||
+      st.size > 2048
+    )
+      throw Error("Unsafe owner operation journal.");
+    journal = JSON.parse(await h.readFile("utf8"));
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  } finally {
+    await h?.close();
+  }
+  const persist = async (value) => {
+    if (value) await onSubmitted?.(value);
+    const { rename } = await import("node:fs/promises");
+    const temp = journalPath + "." + randomBytes(8).toString("hex");
+    await writeFile(temp, JSON.stringify(value), { mode: 0o600, flag: "wx" });
+    await rename(temp, journalPath);
+  };
+  assets.set(
+    "plan.js",
+    Buffer.concat([
+      assets.get("plan.js"),
+      Buffer.from(
+        "window.agentpayOwnerJournal=" +
+          JSON.stringify(journal).replace(/</g, "\\u003c") +
+          ";window.agentpayJournalServer=true;",
+      ),
+    ]),
+  );
+  const { server, prefix } = createOwnerServer(assets, {
+    saveJournal: persist,
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const port = server.address().port,
+    url = "http://127.0.0.1:" + port + prefix;
+  write("\n> Approve with your Safe owner wallet\nOpen: " + url);
+  openBrowser(url);
+  const remoteHelp = `On a headless server, forward port ${port} through SSH, then open the same address on your computer.\nExample: ssh -N -L ${port}:127.0.0.1:${port} USER@SERVER`;
+  try {
+    for (;;) {
+      const choice = (
+        await ask(
+          "After execution, enter 'check'. Enter 'help' for remote access, 'export' for a portable page, or 'q' to pause.",
+        )
+      ).trim();
+      if (choice === "q") return false;
+      if (choice === "help") {
+        write(remoteHelp);
+        continue;
+      }
+      if (choice === "export") {
+        await onSubmitted?.({ kind: "export" });
+        const folder = await exportOwnerPage(assets, dataDir);
+        write(
+          `Portable page: ${folder}\nCopy this directory to a trusted computer. In that directory run:\n  node serve.mjs\nOr:\n  python3 -m http.server 8765 --bind 127.0.0.1\nThen open http://127.0.0.1:8765 (Python) or the address printed by Node.\nKeep the files until this authorization is complete; remove the exported directory afterward.`,
+        );
+        continue;
+      }
+      if (choice !== "check") continue;
+      try {
+        if (await check()) {
+          write("On-chain operations verified. Continuing.");
+          return true;
+        }
+        write(
+          "Not complete yet. Finish the Safe operations, then check again.",
+        );
+      } catch {
+        write("Could not verify yet. Check your RPC connection, then retry.");
+      }
+    }
+  } finally {
+    server.closeAllConnections();
+    await new Promise((resolve) => server.close(resolve));
+  }
+}