@c4roa0/agentpay-user 0.0.0-stage → 0.3.0

package/src/repair-market-wallet.mjs

@@ -0,0 +1,137 @@
+import { ensureRuntimeConnection } from "./runtime-connection-settings.mjs";
+import { walletPackage } from "./wallet-package.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 { spawn } from "node:child_process";
+import { open, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { installedUserDir } from "./local-data-directory.mjs";
+import { checkServiceDirectory } from "./local-services.mjs";
+import { ensureLocalServices } from "./prepare-local-services.mjs";
+import { runInstall } from "./install-user.mjs";
+import { localWalletAdmin } from "./local-wallet-ipc.mjs";
+import { controlWallet } from "./wallet-control.mjs";
+
+async function service(action, { userDir, dataDir, logPath }) {
+  const log = await open(logPath, "a", 0o600);
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn(
+        process.execPath,
+        [join(userDir, "scripts/autostart.mjs"), action],
+        {
+          shell: false,
+          env: { ...process.env, AGENTPAY_USER_DATA_DIR: dataDir },
+          stdio: ["ignore", log.fd, log.fd],
+        },
+      );
+      child.once("error", reject);
+      child.once("exit", (code) =>
+        code === 0 ? resolve() : reject(Error("Service preparation failed.")),
+      );
+    });
+  } finally {
+    await log.close();
+  }
+}
+export async function repairMarketWallet({
+  dataDir,
+  write = console.log,
+  userDir = installedUserDir,
+  prepare = runInstall,
+  connection = ensureRuntimeConnection,
+  manage = service,
+  wallet = localWalletAdmin,
+  unlock = controlWallet,
+  inspectPackage = walletPackage,
+  checkDirectory = checkServiceDirectory,
+  ensureSettings = ensureLocalServices,
+  pause = (ms) => new Promise((r) => setTimeout(r, ms)),
+}) {
+  let logPath,
+    servicesPaused = false;
+  try {
+    await inspectPackage(userDir);
+    await checkDirectory(dataDir);
+    await ensureSettings({ dataDir, userDir, write, connectionOptions: { refreshClientModule: true, checkOnly: true } });
+    logPath = join(
+      dataDir,
+      "runtime",
+      `wallet-prepare-${Date.now()}-${randomUUID()}.log`,
+    );
+    const context = { userDir, dataDir, logPath };
+    write("1/3 Prepare Wallet. Your background services will pause briefly.");
+    await prepare({
+      userDir,
+      dataDir,
+      prepareOnly: true,
+      write: () => {},
+      // The installer lock covers service changes as well as dependency checks.
+      // A competing repair must fail before pausing a running Wallet.
+      beforePrepare: async () => {
+        await connection({ dataDir, write, refreshClientModule: true, checkOnly: true });
+        await manage("prepare-repair", context);
+        await manage("stop", context);
+        servicesPaused = true;
+        write("2/3 Verify installed User and Wallet packages.");
+      },
+      afterPrepare: async () => {
+        await connection({ dataDir, write, refreshClientModule: true });
+        write("3/3 Start Wallet and Runtime.");
+        await manage("start", context);
+        servicesPaused = false;
+      },
+    });
+    let ready = false;
+    for (let attempt = 0; attempt < 30; attempt++) {
+      try {
+        await wallet(dataDir, "status");
+        ready = true;
+        break;
+      } catch (e) {
+        if (e.code !== "WALLET_NOT_RUNNING") throw e;
+        await pause(500);
+      }
+    }
+    if (!ready) throw Error("START_TIMEOUT");
+    await wallet(dataDir, "marketConnectionScope");
+    const state = await wallet(dataDir, "status");
+    if (
+      state.locked &&
+      (await unlock("unlock", {
+        args: [dataDir],
+        write: (m) => {
+          if (!m.startsWith("Wallet unlocked.")) write(m);
+        },
+      })) !== 0
+    )
+      return false;
+    if ((await wallet(dataDir, "status")).locked)
+      throw Error("UNLOCK_REQUIRED");
+    write("Wallet is ready. Continuing your Market connection.");
+    return true;
+  } catch (e) {
+    if (e.message === "CURRENT_SOURCE_REQUIRED")
+      write(
+        "Install the reviewed User package, then run agentpay market connect again.",
+      );
+    else {
+      if (!logPath)
+        write(
+          "Startup settings were not completed. Run agentpay service start in your terminal, then retry this connection.",
+        );
+      if (e.preparationMessage) write(e.preparationMessage);
+      if (servicesPaused)
+        write(
+          "Wallet and Runtime remain stopped until preparation succeeds. Your keys and Order records are kept.",
+        );
+      write(
+        "Wallet preparation stopped. Run agentpay market connect again after checking the log.",
+      );
+      if (e.logPath || logPath) write("Log: " + (e.logPath || logPath));
+    }
+    return false;
+  }
+}

package/src/restore-wallet.mjs

@@ -0,0 +1,255 @@
+// 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 { createInterface } from "node:readline/promises";
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { getAddress, formatUnits } from "ethers";
+import {
+  resolveUserDataDir,
+  installedUserDir,
+} from "./local-data-directory.mjs";
+import { inspectLocalUserSetup } from "./user-setup-guide.mjs";
+import { ensureLocalServices } from "./prepare-local-services.mjs";
+import { localWalletAdmin } from "./local-wallet-ipc.mjs";
+import { controlWallet } from "./wallet-control.mjs";
+import { displaySeconds } from "./local-time.mjs";
+export const restoreMessages = {
+  METHOD_NOT_ALLOWED:
+    "This Wallet build does not support restoration. Install compatible User and Wallet versions, then retry agentpay wallet restore.",
+  RESTORE_CONTRACT_MISSING:
+    "A required contract is missing. Check the network, Safe and Module addresses.",
+  RESTORE_CHAIN_UNAVAILABLE:
+    "The chain could not be read. Check your RPC connection and retry agentpay wallet restore.",
+  RESTORE_TARGET_INVALID:
+    "Check the network, Module, Safe and original Policy ID.",
+  POLICY_KEY_MISMATCH:
+    "This Policy belongs to a different Session Key. Use its original key.",
+  POLICY_ALREADY_BOUND:
+    "This Wallet already uses another Policy. Its binding was kept.",
+  RESTORE_POLICY_NOT_FOUND:
+    "No Policy was found for this Safe and ID. Check the network, Module and Policy ID.",
+  RESTORE_POLICY_REVOKED:
+    "This Policy was revoked and cannot be restored for spending.",
+  RESTORE_POLICY_EXPIRED:
+    "This Policy has expired. Restoring a key does not renew spending permission.",
+  RESTORE_POLICY_NOT_ACTIVE:
+    "This Policy is not active yet. Try again after its start time.",
+  RESTORE_MODULE_DISABLED:
+    "The Safe has disabled this Module. Restore does not enable it.",
+  MIGRATION_CHAIN_MISMATCH:
+    "The RPC returned a different network. Check its address.",
+  LOCKED: "Wallet is locked. Unlock it before restoring the authorization.",
+  CANCELLED: "Restoration paused. Existing Wallet data was kept.",
+};
+async function askTerminal(message) {
+  if (!process.stdin.isTTY)
+    throw Error("Run agentpay wallet restore in an interactive terminal.");
+  const r = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await r.question(message + "\n> ");
+  } finally {
+    r.close();
+  }
+}
+async function run(script, args, dataDir) {
+  const code = await new Promise((done, reject) => {
+    const c = spawn(
+      process.execPath,
+      [join(installedUserDir, "scripts", script), ...args],
+      {
+        stdio: "inherit",
+        env: { ...process.env, AGENTPAY_USER_DATA_DIR: dataDir },
+      },
+    );
+    c.once("error", reject);
+    c.once("exit", done);
+  });
+  if (code !== 0)
+    throw Error(
+      "Local preparation did not finish. Retry agentpay wallet restore.",
+    );
+}
+export async function restoreExistingPolicy({
+  dataDir,
+  target,
+  ask = askTerminal,
+  write = console.log,
+  expectedDeployment = null,
+  previewOnly = false,
+  ops = {},
+}) {
+  const services = {
+    ensure: ensureLocalServices,
+    wallet: localWalletAdmin,
+    unlock: controlWallet,
+    run,
+    ...ops,
+  };
+  let status;
+  try {
+    status = await services.wallet(dataDir, "status");
+  } catch (e) {
+    if (e.code !== "WALLET_NOT_RUNNING") throw e;
+  }
+  if (!status) {
+    await services.ensure({ dataDir, ask, write });
+    await services.run("autostart.mjs", ["prepare"], dataDir);
+    await services.run("autostart.mjs", ["start"], dataDir);
+    for (let i = 0; i < 30; i++) {
+      try {
+        status = await services.wallet(dataDir, "status");
+        break;
+      } catch (e) {
+        if (e.code !== "WALLET_NOT_RUNNING") throw e;
+        await new Promise((r) => setTimeout(r, 300));
+      }
+    }
+  }
+  if (!status)
+    throw Error("Wallet did not start. Run agentpay status before retrying.");
+  if (
+    status.locked &&
+    (await services.unlock("unlock", { args: [dataDir], write })) !== 0
+  )
+    throw Object.assign(Error(), { code: "CANCELLED" });
+  const preview = await services.wallet(dataDir, "previewPolicyRestore", {
+    target,
+  });
+  if (
+    expectedDeployment &&
+    ["factory", "registry", "token", "module"].some(
+      (k) =>
+        preview.policy[k].toLowerCase() !== expectedDeployment[k].toLowerCase(),
+    )
+  )
+    throw Error(
+      "This Policy uses another deployment. Use agentpay wallet restore separately; the current setup test cannot use it.",
+    );
+  if (previewOnly) return preview;
+  write(
+    "\n------------------------------------------------------------\n> Restore spending permission\n------------------------------------------------------------",
+  );
+  write(
+    `Safe: ${preview.policy.safe}\nPolicy ID: ${preview.policy.policyId}\nNetwork: eip155:${preview.policy.chainId}`,
+  );
+  const amount = (value) =>
+    expectedDeployment
+      ? `${formatUnits(value, expectedDeployment.tokenDecimals)} ${expectedDeployment.tokenSymbol || "tokens"}`
+      : `${value} atomic units (token ${preview.policy.token})`;
+  if (expectedDeployment)
+    write(
+      `Remaining budget: ${amount(preview.remainingBudget)}\nPer-purchase limit: ${amount(preview.policy.maxAmount)}`,
+    );
+  write(`Expires: ${displaySeconds(preview.policy.validUntil)}`);
+  if (preview.remainingBudget === "0")
+    write(
+      "No budget remains. Restoring this identity does not enable new purchases.",
+    );
+  write("Use this existing permission. Its limits and expiry will not change.");
+  while (true) {
+    const value = (
+      await ask(
+        "Type 'confirm' to restore, 'details' for existing limits, or 'q' to return.",
+      )
+    ).trim();
+    if (value === "q") throw Object.assign(Error(), { code: "CANCELLED" });
+    if (value === "details") {
+      write(
+        `Remaining budget: ${amount(preview.remainingBudget)}\nPer-purchase limit: ${amount(preview.policy.maxAmount)}`,
+      );
+      continue;
+    }
+    if (value === "confirm") break;
+  }
+  const result = await services.wallet(dataDir, "restorePolicy", { target });
+  write(
+    "Original Policy restored locally. No new authorization or payment was made.",
+  );
+  return result;
+}
+export async function runWalletRestore({
+  ask = askTerminal,
+  write = console.log,
+  resolveDirectory = resolveUserDataDir,
+  ops = {},
+} = {}) {
+  try {
+    const dataDir = await resolveDirectory();
+    let local = await inspectLocalUserSetup(dataDir);
+    if (local.stage !== "initialized") {
+      write(
+        "First restore your original Session Key. Wallet will ask for secrets privately.",
+      );
+      await (ops.run || run)(
+        "setup-local.mjs",
+        ["install", dataDir, "--restore"],
+        dataDir,
+      );
+      local = await inspectLocalUserSetup(dataDir);
+      if (local.stage !== "initialized") return 0;
+    }
+    const field = async (prompt, validate) => {
+      while (true) {
+        const value = (await ask(prompt + " ('q' to return)")).trim();
+        if (value === "q") throw Object.assign(Error(), { code: "CANCELLED" });
+        try {
+          return validate(value);
+        } catch {
+          write("Check this value and try again.");
+        }
+      }
+    };
+    write(
+      "Find your original Policy ID in Market → Wallets, or your saved agentpay wallet info.",
+    );
+    const chainId = await field("Network chain ID (for example 31337)", (v) => {
+      const n = Number(v);
+      if (!/^[1-9][0-9]*$/.test(v) || !Number.isSafeInteger(n)) throw Error();
+      return n;
+    });
+    const rpcUrl = await field("RPC address for this network", (v) => {
+      const u = new URL(v);
+      if (
+        u.username ||
+        u.password ||
+        u.search ||
+        u.hash ||
+        !(
+          u.protocol === "https:" ||
+          (u.protocol === "http:" &&
+            ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname))
+        )
+      )
+        throw Error();
+      return u.href;
+    });
+    const module = await field(
+        "AgentPay Module address from your saved settings",
+        getAddress,
+      ),
+      safe = await field("Original Safe account address", getAddress),
+      policyId = await field("Original Policy ID", (v) => {
+        if (!/^0x[0-9a-f]{64}$/i.test(v) || /^0x0+$/.test(v)) throw Error();
+        return v.toLowerCase();
+      });
+    await restoreExistingPolicy({
+      dataDir,
+      target: { chainId, rpcUrl, module, safe, policyId },
+      ask,
+      write,
+      ops,
+    });
+    write(
+      "Restore finished. Use agentpay status to check services and retained Orders.",
+    );
+    return 0;
+  } catch (e) {
+    write(
+      restoreMessages[e.code] ||
+        e.message ||
+        "Restoration could not complete. Check the network and retry agentpay wallet restore; existing data was kept.",
+    );
+    return e.code === "CANCELLED" ? 0 : 1;
+  }
+}

package/src/result-cache-view.mjs

@@ -0,0 +1,276 @@
+// 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, opendir, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const b32 = /^0x[0-9a-f]{64}$/;
+// A display-only view. No Skill package selection, execution or payment is involved.
+// Both durable result stores stay unchanged and excluded from attachment cleanup.
+export function withResultCacheView(
+  operate,
+  dataDir,
+  { statePath = join(dataDir, "runtime", "invocations.json") } = {},
+) {
+  const clientDirectory = join(dataDir, "runtime", "client-requests");
+  async function privateJson(path, max = 2 * 1048576) {
+    let h;
+    try {
+      h = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+      const stat = await h.stat();
+      if (
+        !stat.isFile() ||
+        stat.nlink !== 1 ||
+        stat.size > max ||
+        (typeof process.getuid === "function" &&
+          (stat.uid !== process.getuid() || stat.mode & 0o077))
+      )
+        throw Error("Saved cache metadata needs inspection.");
+      const bytes = await h.readFile();
+      if (bytes.length > max) throw Error("Saved cache metadata is too large.");
+      return { value: JSON.parse(bytes.toString("utf8")), stat, bytes };
+    } finally {
+      await h?.close();
+    }
+  }
+  async function scan(directory, pattern, read) {
+    let st;
+    try {
+      st = await lstat(directory);
+    } catch (e) {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    }
+    if (
+      !st.isDirectory() ||
+      st.isSymbolicLink() ||
+      (typeof process.getuid === "function" &&
+        (st.uid !== process.getuid() || st.mode & 0o077))
+    )
+      throw Error("Saved cache directory needs inspection.");
+    const rows = [];
+    for await (const entry of await opendir(directory))
+      if (pattern.test(entry.name))
+        rows.push(await read(join(directory, entry.name), entry.name));
+    return rows;
+  }
+  const source = (reference) =>
+    typeof reference?.profile?.providerId === "string"
+      ? reference.profile.providerId
+      : undefined;
+  function row(file, result, id, requestId, providerId) {
+    if (!b32.test(result?.orderId || "") || result.output === undefined)
+      throw Error("Saved result needs inspection.");
+    return {
+      id,
+      kind: "result",
+      purpose: "output",
+      state: "available",
+      filename: "Result.json",
+      fileKey: "structured-result",
+      contentDigest: hash(JSON.stringify(result.output)),
+      contentBytes: Buffer.byteLength(JSON.stringify(result.output)),
+      bytes: file.bytes.length,
+      sha256: hash(file.bytes),
+      localPath: file.path,
+      requestId,
+      orderId: result.orderId,
+      providerId,
+      skillId: result.service?.skillId,
+      profileHash: result.service?.profileHash,
+      requestHash: result.requestHash,
+      outputHash: result.outputHash,
+      updatedAtMs: file.stat.mtimeMs,
+      protected: true,
+    };
+  }
+  async function inventory() {
+    const clients = await scan(
+      clientDirectory,
+      /^[0-9a-f]{64}\.result\.json$/,
+      async (path, name) => {
+        const file = await privateJson(path),
+          v = file.value;
+        if (
+          v.version !== "agentpay.runtime-client-result.v1" ||
+          typeof v.requestId !== "string" ||
+          hash(v.requestId) + ".result.json" !== name ||
+          v.body?.ok !== true
+        )
+          throw Error("Saved result needs inspection.");
+        let reference;
+        try {
+          const c = (
+            await privateJson(path.replace(/\.result\.json$/, ".json"))
+          ).value;
+          if (
+            c.version === "agentpay.runtime-client-request.v1" &&
+            c.requestId === v.requestId
+          )
+            reference = c.service;
+        } catch (e) {
+          if (e.code !== "ENOENT") throw e;
+        }
+        return row(
+          { ...file, path },
+          v.body.result,
+          "result:" + name.slice(0, 64),
+          v.requestId,
+          source(reference),
+        );
+      },
+    );
+    const runtime = await scan(
+      statePath + ".results",
+      /^0x[0-9a-f]{64}\.json$/,
+      async (path, name) => {
+        const file = await privateJson(path),
+          v = file.value;
+        if (
+          v.version !== "agentpay.invocation-result.v1" ||
+          v.invocationId + ".json" !== name
+        )
+          throw Error("Saved Runtime result needs inspection.");
+        let reference;
+        try {
+          reference = JSON.parse(v.serviceBinding).reference;
+        } catch {}
+        return row(
+          { ...file, path },
+          v.result,
+          "runtime-result:" + v.invocationId,
+          undefined,
+          source(reference),
+        );
+      },
+    );
+    const all = [...clients, ...runtime],
+      logical = new Map();
+    for (const r of all) {
+      // Merge only proven identical output for the same Order/service/request. Missing
+      // legacy identity stays separate rather than guessing that two records match.
+      const key = [
+        r.orderId,
+        r.skillId,
+        r.profileHash,
+        r.requestHash,
+        r.outputHash,
+      ].every(Boolean)
+        ? JSON.stringify([
+            r.orderId,
+            r.skillId,
+            r.profileHash,
+            r.requestHash,
+            r.outputHash,
+            r.contentDigest,
+          ])
+        : r.id;
+      const previous = logical.get(key);
+      if (previous) {
+        previous.storageBytes += r.bytes;
+        previous.copyIds.push(r.id);
+        previous.providerId ??= r.providerId;
+        previous.requestIds.push(...(r.requestId ? [r.requestId] : []));
+      } else
+        logical.set(key, {
+          ...r,
+          storageBytes: r.bytes,
+          copyIds: [r.id],
+          requestIds: r.requestId ? [r.requestId] : [],
+        });
+    }
+    return {
+      all,
+      rows: [...logical.values()],
+      bytes: all.reduce((n, r) => n + r.bytes, 0),
+    };
+  }
+  return async (body) => {
+    if (
+      ["details", "verified"].includes(body.action) &&
+      /^(?:result|runtime-result):/.test(String(body.id))
+    ) {
+      if (
+        !/^(?:result:[0-9a-f]{64}|runtime-result:0x[0-9a-f]{64})$/.test(body.id)
+      )
+        throw Error("Invalid cache ID.");
+      const inv = await inventory(),
+        found = inv.all.find((r) => r.id === body.id);
+      if (!found) throw Error("Cached result not found.");
+      return {
+        ...found,
+        storageBytes: inv.rows.find((r) => r.copyIds.includes(body.id))
+          ?.storageBytes,
+      };
+    }
+    if (body.action === "summary") {
+      const base = await operate(body),
+        results = await inventory();
+      return {
+        ...base,
+        resultRecords: results.rows.length,
+        resultBytes: results.bytes,
+      };
+    }
+    if (body.action === "list") {
+      const { offset = 0, limit = 100 } = body;
+      if (
+        !Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > 100
+      )
+        throw Error("Invalid cache page.");
+      const first = await operate({
+          ...body,
+          offset: 0,
+          limit: Math.min(100, offset + limit),
+        }),
+        items = [...first.items];
+      // Only the first offset+limit attachments can occur in the merged page.
+      for (
+        let at = items.length;
+        at < Math.min(first.total, offset + limit);
+
+      ) {
+        const page = await operate({
+          ...body,
+          offset: at,
+          limit: Math.min(100, offset + limit - at),
+        });
+        if (!page.items.length) break;
+        items.push(...page.items);
+        at += page.items.length;
+      }
+      const results = await inventory();
+      for (const r of items) {
+        const matching = results.rows.find(
+          (v) =>
+            (r.orderId && v.orderId === r.orderId) ||
+            (r.requestId && v.requestIds.includes(r.requestId)),
+        );
+        r.providerId = matching?.providerId;
+      }
+      const text = results.rows.filter(
+        (r) =>
+          (!body.purpose || body.purpose === r.purpose) &&
+          (!body.state || body.state === r.state) &&
+          (!body.requestId || r.requestIds.includes(body.requestId)) &&
+          (!body.orderId || body.orderId === r.orderId),
+      );
+      items.push(...text);
+      items.sort(
+        (a, b) => b.updatedAtMs - a.updatedAtMs || a.id.localeCompare(b.id),
+      );
+      return {
+        total: first.total + text.length,
+        items: items.slice(offset, offset + limit),
+      };
+    }
+    return operate(body);
+  };
+}