@c4roa0/agentpay-user 0.0.0-stage → 0.3.0

package/scripts/install-user.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// 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 { fileURLToPath } from "node:url";
+import { resolveUserDataDir } from "../src/local-data-directory.mjs";
+import { installAndSetup } from "../src/install-and-setup.mjs";
+try {
+  const args = process.argv.slice(2);
+  if (args.length !== 2 || args[0] !== "--market")
+    throw Error("Usage: agentpay install --market MARKET_URL");
+  if (!process.stdin.isTTY)
+    throw Error(
+      "Run Install in an interactive terminal so setup can continue.",
+    );
+  process.exitCode = await installAndSetup({
+    userDir: fileURLToPath(new URL("..", import.meta.url)),
+    market: args[1],
+    dataDir: await resolveUserDataDir(),
+  });
+} catch (error) {
+  if (!error.messageDisplayed) console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/local-service.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { walletCliPath } from "../src/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 { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  readServiceSettings,
+  runtimeEnvironment,
+  listenerPresent,
+} from "../src/local-services.mjs";
+const [role, directory, ...extra] = process.argv.slice(2);
+try {
+  if (!["wallet", "runtime"].includes(role) || !directory || extra.length)
+    throw Error("Invalid service arguments.");
+  const dataDir = resolve(directory),
+    settings = await readServiceSettings(dataDir);
+  const address =
+    role === "wallet"
+      ? join(dataDir, "wallet", "wallet.sock")
+      : { host: "127.0.0.1", port: Number(new URL(settings.runtimeUrl).port) };
+  if (await listenerPresent(address))
+    throw Error(
+      "A process already uses this Wallet socket or Runtime port. Stop it explicitly before starting managed services.",
+    );
+  const userDir = fileURLToPath(new URL("..", import.meta.url));
+  const entry =
+    role === "wallet"
+      ? walletCliPath()
+      : join(userDir, "src/index.mjs");
+  const env = Object.fromEntries(
+    ["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR"]
+      .filter((k) => process.env[k])
+      .map((k) => [k, process.env[k]]),
+  );
+  if (role === "runtime")
+    Object.assign(env, runtimeEnvironment(dataDir, settings));
+  const child = spawn(
+    process.execPath,
+    [entry, ...(role === "wallet" ? ["serve", join(dataDir, "wallet")] : [])],
+    { env, stdio: "inherit", shell: false },
+  );
+  const stop = () => child.kill("SIGTERM");
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  child.once("error", () => {
+    console.error("Local service could not start.");
+    process.exitCode = 1;
+  });
+  child.once("exit", (code) => {
+    process.off("SIGTERM", stop);
+    process.off("SIGINT", stop);
+    process.exitCode = code ?? 1;
+  });
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/lock.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// 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 { controlWallet } from "../src/wallet-control.mjs";
+try {
+  process.exitCode = await controlWallet("lock");
+} catch {
+  console.error("Could not start Wallet lock. Check your local installation.");
+  process.exitCode = 1;
+}

package/scripts/login-notify.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { walletCliPath } from "../src/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 { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveUserDataDir } from "../src/local-data-directory.mjs";
+import { remindLockedWallet } from "../src/login-reminder.mjs";
+const execute = promisify(execFile);
+try {
+  if (process.argv.length > 3) throw Error();
+  const dataDir = await resolveUserDataDir({ argument: process.argv[2] });
+  const cli = walletCliPath();
+  await remindLockedWallet({
+    status: async () => {
+      const { stdout } = await execute(
+        process.execPath,
+        [cli, "status", join(dataDir, "wallet")],
+        { timeout: 3000, maxBuffer: 16384 },
+      );
+      return JSON.parse(stdout);
+    },
+    notify: () =>
+      execute(
+        "notify-send",
+        [
+          "--app-name=AgentPay",
+          "AgentPay Wallet is locked",
+          "To resume payments, open the User folder in a terminal and run: agentpay wallet unlock",
+        ],
+        { timeout: 5000, maxBuffer: 4096 },
+      ),
+  });
+} catch {
+  /* Notifications are best effort; no secret, prompt or background unlock. */
+}

package/scripts/migrate-safe-policy.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// 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 { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { callWallet, readCapability } from "@c4roa0/agentpay-wallet";
+import {
+  migrationSummary,
+  migratedPublicPolicy,
+  syncMigratedPublicPolicy,
+} from "../src/policy-migration.mjs";
+import { executeAnvilOwnerCall } from "../src/safe-owner-anvil.mjs";
+
+const [command, directory, argument, ...extra] = process.argv.slice(2);
+const withArgument = [
+  "preview",
+  "prepare",
+  "complete",
+  "cancel",
+  "authorize-test",
+];
+if (
+  !directory ||
+  extra.length ||
+  ![...withArgument, "status", "export", "refresh"].includes(command) ||
+  (withArgument.includes(command) ? !argument : argument !== undefined)
+) {
+  throw new Error(
+    "usage: migrate-safe-policy.mjs <preview|prepare|status|export|authorize-test|complete|cancel|refresh> <private-user-data-dir> [target.json|migration-id|test-owner-address]",
+  );
+}
+const walletDir = join(resolve(directory), "wallet");
+const capability = await readCapability(walletDir, "admin");
+const call = (method, params = {}) =>
+  callWallet(join(walletDir, "wallet.sock"), capability, method, params);
+const print = (value) =>
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+if (["preview", "prepare"].includes(command)) {
+  const target = JSON.parse(await readFile(resolve(argument), "utf8"));
+  const status = await call("policyMigrationStatus");
+  if (status.state === "pending") {
+    if (
+      target.expectedPolicyId !== status.plan.source.policyId ||
+      target.policyId.toLowerCase() !== status.plan.destination.policyId ||
+      target.factory.toLowerCase() !==
+        status.plan.destination.factory.toLowerCase() ||
+      target.module.toLowerCase() !==
+        status.plan.destination.module.toLowerCase()
+    )
+      throw new Error("MIGRATION_CONFLICT");
+    print({ ...status, summary: migrationSummary(status.plan), resumed: true });
+  } else {
+    const plan = await call("previewPolicyMigration", { target });
+    print({ summary: migrationSummary(plan) });
+    if (command === "prepare") {
+      await confirm(
+        `MIGRATE ${plan.migrationId}`,
+        "Pause Wallet signing and save this migration",
+      );
+      print(
+        await call("preparePolicyMigration", {
+          target,
+          migrationId: plan.migrationId,
+        }),
+      );
+    }
+  }
+} else if (command === "refresh") {
+  const preview = await call("previewPolicyMigrationRefresh");
+  print({
+    previousMigrationId: preview.previousMigrationId,
+    summary: migrationSummary(preview.plan),
+  });
+  await confirm(
+    `MIGRATE ${preview.plan.migrationId}`,
+    "Save the recalculated remaining budget for the same destination",
+  );
+  print(
+    await call("refreshPolicyMigration", {
+      previousMigrationId: preview.previousMigrationId,
+      migrationId: preview.plan.migrationId,
+    }),
+  );
+} else if (command === "authorize-test") {
+  let status = await call("policyMigrationStatus");
+  if (status.state !== "pending") throw new Error("MIGRATION_NOT_PENDING");
+  print({ summary: migrationSummary(status.plan), chain: status.chain });
+  if (status.chain.expired) throw new Error("MIGRATION_POLICY_EXPIRED");
+  const migrationId = status.plan.migrationId;
+  await confirm(
+    `AUTHORIZE ${migrationId}`,
+    "Submit the displayed Safe owner transactions on private Anvil",
+  );
+  while (status.chain.calls.length) {
+    print(
+      await executeAnvilOwnerCall(status.plan, argument, status.chain.calls[0]),
+    );
+    // Never submit the next call until independent Wallet chain inspection succeeds.
+    status = await call("policyMigrationStatus");
+    if (
+      status.state !== "pending" ||
+      status.plan.migrationId !== migrationId ||
+      status.chain.expired
+    )
+      throw new Error("MIGRATION_CHANGED");
+  }
+  print({ ownerTransactionsVerified: true, migrationId, next: "complete" });
+} else if (command === "complete") {
+  const status = await call("completePolicyMigration", {
+    migrationId: argument,
+  });
+  const publicPolicyPath = await syncMigratedPublicPolicy(
+    resolve(directory),
+    status.plan,
+  );
+  print({
+    ...status,
+    publicPolicyConfig: migratedPublicPolicy(status.plan),
+    publicPolicyPath,
+    next: "Synchronize runtime deployment metadata, restart callers, check readiness, then unlock Wallet. Admission remains an operator decision.",
+  });
+} else if (command === "cancel") {
+  await confirm(
+    `CANCEL ${argument}`,
+    "Cancel only if the old Policy is still active and the replacement does not exist",
+  );
+  print(await call("cancelPolicyMigration", { migrationId: argument }));
+} else {
+  const status = await call("policyMigrationStatus");
+  if (command === "export") {
+    if (status.state !== "pending" || status.chain.expired)
+      throw new Error("MIGRATION_NOT_PENDING_OR_EXPIRED");
+    // Export only the next call: confirm it on chain and export again. This prevents
+    // an owner UI from treating creation-before-revocation as a supported ordering.
+    const { calls, ...chain } = status.chain;
+    print({
+      summary: migrationSummary(status.plan),
+      chain,
+      safe: status.plan.source.safe,
+      chainId: status.plan.source.chainId,
+      nextSafeCall: calls[0] ?? null,
+    });
+  } else print(status);
+}
+
+async function confirm(expected, action) {
+  // Public confirmation prompts may be captured by run_debug's tee; input must
+  // still come from the interactive terminal, never a pipe/environment variable.
+  if (!process.stdin.isTTY) throw new Error("OWNER_AUTHORIZATION_TTY_REQUIRED");
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+  try {
+    if (
+      (await prompt.question(`${action}. Type '${expected}': `)).trim() !==
+      expected
+    )
+      throw new Error("OWNER_AUTHORIZATION_NOT_CONFIRMED");
+  } finally {
+    prompt.close();
+  }
+}

package/scripts/official-paid-test.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// 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 { runOfficialPaidTest } from "../src/official-paid-test.mjs";
+if (process.argv.length !== 2) {
+  console.error("Use agentpay payment test.");
+  process.exitCode = 2;
+} else process.exitCode = await runOfficialPaidTest();

package/scripts/poll-unconfirmed-notice.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// 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/.
+// Poll only through the authenticated, bounded Wallet IPC notice operation.
+import { lstat, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { assertUnixMilliseconds } from "@c4roa0/agentpay-protocol";
+import { callWallet } from "@c4roa0/agentpay-wallet";
+
+const [dataArg, settlementArg] = process.argv.slice(2);
+if (!dataArg || !settlementArg || process.argv.length !== 4)
+  throw new Error(
+    "usage: poll-unconfirmed-notice.mjs <user-dir> <settlement-url>",
+  );
+const url = new URL(settlementArg);
+if (
+  url.protocol !== "http:" ||
+  !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)
+)
+  throw new Error("loopback required");
+const dataDir = resolve(dataArg);
+const checkpoint = JSON.parse(
+  await readFile(join(dataDir, "runtime/unconfirmed-smoke.json"), "utf8"),
+);
+if (!/^0x[0-9a-f]{64}$/.test(checkpoint.orderId || ""))
+  throw new Error("Order checkpoint missing");
+const tokenPath = join(dataDir, "wallet/agent.token");
+const info = await lstat(tokenPath);
+if (
+  !info.isFile() ||
+  info.isSymbolicLink() ||
+  info.uid !== process.getuid() ||
+  info.mode & 0o077
+)
+  throw new Error("unsafe Wallet capability");
+const token = (await readFile(tokenPath, "utf8")).trim();
+if (!/^[0-9a-f]{64}$/.test(token)) throw new Error("invalid Wallet capability");
+const answer = await callWallet(
+  join(dataDir, "wallet/wallet.sock"),
+  token,
+  "pollSettlementNotices",
+  { settlementUrl: url.toString(), limit: 50 },
+);
+const notices = answer?.notices || [];
+const matches = notices.filter(
+  (notice) =>
+    notice.orderId === checkpoint.orderId &&
+    notice.type === "delivery_confirmation_required",
+);
+if (
+  matches.length !== 1 ||
+  matches[0].state !== "delivered" ||
+  matches[0].payload?.orderId !== checkpoint.orderId ||
+  !Number.isSafeInteger(matches[0].payload?.releaseScheduledAtMs)
+) {
+  throw new Error("one bound Wallet reminder was not returned");
+}
+process.stdout.write(
+  `${JSON.stringify(
+    {
+      ok: true,
+      orderId: checkpoint.orderId,
+      walletAuthenticated: true,
+      uniqueOrderNotice: true,
+      noticeState: matches[0].state,
+      availableActions: matches[0].payload.actions,
+      releaseScheduledAtMs: assertUnixMilliseconds(
+        matches[0].payload.releaseScheduledAtMs,
+      ),
+    },
+    null,
+    2,
+  )}\n`,
+);

package/scripts/prepare-onboarding.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// 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 { isAbsolute } from "node:path";
+import { prepareOnboarding } from "../src/prepare-onboarding.mjs";
+let terminal;
+try {
+  const args = process.argv.slice(2);
+  if (args.length !== 2 || !args.every(isAbsolute))
+    throw Error(
+      "Usage: node scripts/prepare-onboarding.mjs ABSOLUTE_PUBLIC_DEPLOYMENT_JSON ABSOLUTE_LOCAL_CONFIG_JSON",
+    );
+  if (!process.stdin.isTTY)
+    throw Error("Run this command in an interactive terminal.");
+  terminal = createInterface({ input: process.stdin, output: process.stdout });
+  await prepareOnboarding({
+    inputPath: args[0],
+    outputPath: args[1],
+    ask: (prompt) => terminal.question(`${prompt}\n> `),
+    write: (line) => console.log(line),
+  });
+} catch (error) {
+  console.error(
+    error.code === "EEXIST"
+      ? "The local configuration already exists. Reuse it with user-setup.mjs; use a different filename for a deliberate new configuration."
+      : error.message,
+  );
+  process.exitCode = 1;
+} finally {
+  terminal?.close();
+}

package/scripts/preview-policy.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// 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 { readFile } from "node:fs/promises";
+import { createPolicyPreviewServer } from "../src/policy-preview-server.mjs";
+try {
+  const demo = process.argv[2] === "--demo";
+  const [path, delegateArg, portArg = "6580"] = process.argv.slice(2);
+  const delegate = demo ? `0x${"5".repeat(40)}` : delegateArg;
+  const host = demo ? process.argv[4] || "127.0.0.1" : "127.0.0.1";
+  if (!["127.0.0.1", "0.0.0.0"].includes(host))
+    throw new Error("Preview host must be 127.0.0.1 or 0.0.0.0");
+  const port = Number(demo ? process.argv[3] || "6580" : portArg);
+  if (
+    (demo
+      ? process.argv.length > 5
+      : !path || !delegate || process.argv.length > 5) ||
+    !Number.isInteger(port) ||
+    port < 1024 ||
+    port > 65535
+  )
+    throw new Error(
+      "Usage: preview-policy.mjs PUBLIC_DEPLOYMENT_JSON WALLET_DELEGATE [PORT] | --demo [PORT] [HOST]",
+    );
+  const deployment = demo
+    ? {
+        chainId: 31337,
+        rpcUrl: "http://127.0.0.1:8545",
+        module: `0x${"1".repeat(40)}`,
+        token: `0x${"2".repeat(40)}`,
+        factory: `0x${"3".repeat(40)}`,
+        registry: `0x${"4".repeat(40)}`,
+        tokenDecimals: 6,
+        source: "界面演示：全部地址是虚构示例，不读取真实 Wallet 或链",
+      }
+    : JSON.parse(await readFile(path, "utf8"));
+  const server = createPolicyPreviewServer({
+    deployment,
+    delegate,
+    demoNetworkPreview: demo && host === "0.0.0.0",
+    ...(demo
+      ? {
+          inspect: async () => ({
+            demo: true,
+            message: "仅展示页面流程；未执行链上核对，不可签名",
+          }),
+        }
+      : {}),
+  });
+  server.on("error", () => {
+    console.error("本地预览无法启动，请检查端口和配置。");
+    process.exitCode = 1;
+  });
+  server.listen(port, host, () =>
+    console.log(
+      `授权预览：http://${host === "0.0.0.0" ? "服务器IP" : host}:${port}/ （监听 ${host}，仅预览，不签名、不写链）`,
+    ),
+  );
+  process.on("SIGINT", () => server.close());
+  process.on("SIGTERM", () => server.close());
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}