@c4roa0/agentpay-user 0.0.0-stage → 0.3.1

package/scripts/random-model-ack-smoke.mjs

@@ -0,0 +1,235 @@
+#!/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/.
+// Private-test model emulator: receipt acknowledgement is a separate caller
+// action after the random result, never an automatic Skill/Runtime side effect.
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, open, readFile, rename, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { loadActiveSkill } from "../src/active-skill.mjs";
+import {
+  loadRuntimeConnection,
+  prepareInvocation,
+  invokeService,
+  completeInvocation,
+} from "../src/runtime-client.mjs";
+import { callWallet } from "@c4roa0/agentpay-wallet";
+
+const [mode, dataArg, settlementArg, userArg] = process.argv.slice(2);
+if (
+  !["invoke", "confirm"].includes(mode) ||
+  !dataArg ||
+  !settlementArg ||
+  !userArg ||
+  process.argv.length !== 6
+) {
+  throw new Error(
+    "usage: random-model-ack-smoke.mjs <invoke|confirm> <private-user-data-dir> <settlement-url> <user-url>",
+  );
+}
+const dataDir = resolve(dataArg);
+const settlementUrl = localUrl(settlementArg);
+const userUrl = localUrl(userArg);
+const runtimeDir = join(dataDir, "runtime");
+const walletDir = join(dataDir, "wallet");
+const checkpointName =
+  process.env.AGENTPAY_MODEL_ACK_CHECKPOINT || "model-ack-smoke.json";
+if (
+  !["model-ack-smoke.json", "unconfirmed-smoke.json"].includes(checkpointName)
+) {
+  throw new Error("unsupported private-test checkpoint");
+}
+const path = join(runtimeDir, checkpointName);
+await privateDirectory(runtimeDir);
+await privateDirectory(walletDir);
+const callerToken = await privateToken(join(runtimeDir, "caller.token"));
+const walletToken = await privateToken(join(walletDir, "agent.token"));
+let checkpoint;
+try {
+  const info = await lstat(path);
+  if (
+    !info.isFile() ||
+    info.isSymbolicLink() ||
+    info.uid !== process.getuid() ||
+    info.mode & 0o077
+  ) {
+    throw new Error("unsafe model-emulator checkpoint");
+  }
+  checkpoint = JSON.parse(await readFile(path, "utf8"));
+} catch (error) {
+  if (error.code !== "ENOENT" || mode !== "invoke") throw error;
+  checkpoint = {
+    version: "agentpay.model-ack-smoke.v1",
+    key: randomUUID(),
+    orderId: null,
+    outputHash: null,
+    confirmed: false,
+    routingVersion: "agentpay.runtime-call.v1",
+  };
+  const handle = await open(path, "wx", 0o600);
+  try {
+    await handle.writeFile(`${JSON.stringify(checkpoint)}\n`);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+if (
+  checkpoint.version !== "agentpay.model-ack-smoke.v1" ||
+  !/^[0-9a-f-]{36}$/.test(checkpoint.key) ||
+  (checkpoint.confirmed && mode === "invoke")
+)
+  throw new Error("invalid or completed model-emulator checkpoint");
+if (
+  mode === "confirm" &&
+  (!/^0x[0-9a-f]{64}$/.test(checkpoint.orderId || "") ||
+    !/^0x[0-9a-f]{64}$/.test(checkpoint.outputHash || ""))
+)
+  throw new Error("invoke must succeed before confirmation");
+
+// Official test input stays here; transaction processing uses the shared client.
+if (checkpoint.routingVersion !== "agentpay.runtime-call.v1")
+  throw Error(
+    "LEGACY_TEST_REVIEW_REQUIRED: preserve the existing request; do not replace its purchase",
+  );
+const material = await loadActiveSkill(join(runtimeDir, "active-skill.json"));
+const connection = await loadRuntimeConnection({ dataDir });
+if (new URL(connection.runtimeUrl).href !== userUrl.href)
+  throw Error("TEST_RUNTIME_CONNECTION_MISMATCH");
+const saved = await prepareInvocation(
+  connection,
+  material.reference,
+  { request: { min: 10, max: 99 }, requestedMaxUsageUnits: "1" },
+  checkpoint.key,
+);
+const body = await invokeService(connection, material.reference, saved);
+await completeInvocation(connection, material.reference, saved);
+const result = body.result;
+if (
+  !/^0x[0-9a-f]{64}$/.test(result?.orderId || "") ||
+  result?.output?.kind !== "random" ||
+  !Number.isSafeInteger(result.output.value) ||
+  result.output.value < 10 ||
+  result.output.value > 99 ||
+  result.deliveryEvidenceVerified !== true ||
+  result.confirmationRequired !== false ||
+  !result.finalization
+) {
+  throw new Error("random result or delivery evidence invalid");
+}
+const outputHash = `0x${createHash("sha256").update(JSON.stringify(result.output)).digest("hex")}`;
+if (
+  checkpoint.orderId &&
+  (checkpoint.orderId !== result.orderId ||
+    checkpoint.outputHash !== outputHash)
+) {
+  throw new Error("retry returned a different Order or random result");
+}
+if (mode === "invoke") {
+  checkpoint = { ...checkpoint, orderId: result.orderId, outputHash };
+  await atomicCheckpoint(path, checkpoint);
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        ok: true,
+        orderId: result.orderId,
+        outputHash,
+        randomResultReceived: true,
+        deliveryEvidenceVerified: true,
+        confirmationSubmitted: false,
+        next:
+          checkpointName === "unconfirmed-smoke.json"
+            ? "do not confirm; observe Wallet reminder and delayed release"
+            : "restart User Runtime, then run confirm with the same private checkpoint",
+      },
+      null,
+      2,
+    )}\n`,
+  );
+} else {
+  if (!checkpoint.confirmed) {
+    const deadline = Date.now() + 30_000;
+    while (true) {
+      try {
+        await callWallet(
+          join(walletDir, "wallet.sock"),
+          walletToken,
+          "confirmSettlementDelivery",
+          { settlementUrl: settlementUrl.toString(), orderId: result.orderId },
+        );
+        break;
+      } catch (error) {
+        if (
+          Date.now() >= deadline ||
+          error?.code !== "SETTLEMENT_REQUEST_REJECTED" ||
+          !String(error?.message || "").includes(
+            "finalization cannot be confirmed",
+          )
+        )
+          throw error;
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
+      }
+    }
+    checkpoint = { ...checkpoint, confirmed: true };
+    await atomicCheckpoint(path, checkpoint);
+  }
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        ok: true,
+        orderId: result.orderId,
+        outputHash,
+        sameOrderAndResultAfterRetry: true,
+        modelEmulatorAcknowledgedReceipt: true,
+        qualityNotJudged: true,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+function localUrl(input) {
+  const url = new URL(input);
+  if (
+    url.protocol !== "http:" ||
+    !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)
+  ) {
+    throw new Error("private loopback URL required");
+  }
+  return url;
+}
+async function privateDirectory(directory) {
+  const info = await lstat(directory);
+  if (
+    !info.isDirectory() ||
+    info.isSymbolicLink() ||
+    info.uid !== process.getuid() ||
+    info.mode & 0o077
+  ) {
+    throw new Error("private user directory required");
+  }
+}
+async function privateToken(file) {
+  const info = await lstat(file);
+  if (
+    !info.isFile() ||
+    info.isSymbolicLink() ||
+    info.uid !== process.getuid() ||
+    info.mode & 0o077
+  ) {
+    throw new Error("private capability file required");
+  }
+  const token = (await readFile(file, "utf8")).trim();
+  if (!/^[0-9a-f]{64}$/.test(token)) throw new Error("capability invalid");
+  return token;
+}
+async function atomicCheckpoint(file, value) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value)}\n`, {
+    flag: "wx",
+    mode: 0o600,
+  });
+  await rename(temporary, file);
+}

package/scripts/random-reject-smoke.mjs

@@ -0,0 +1,147 @@
+#!/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/.
+// Invoke the installed Skill with a durable key; reject/silence are expected negative responses.
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, open, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const [dataArg, userArg] = process.argv.slice(2);
+if (!dataArg || !userArg || process.argv.length !== 4)
+  throw new Error("usage: random-reject-smoke.mjs <user-dir> <user-url>");
+const mode = process.env.AGENTPAY_PROVIDER_NEGATIVE_CASE || "reject";
+if (!["reject", "silence"].includes(mode))
+  throw new Error("unsupported Provider negative case");
+const userUrl = new URL(userArg);
+if (
+  userUrl.protocol !== "http:" ||
+  !["127.0.0.1", "localhost", "[::1]"].includes(userUrl.hostname)
+)
+  throw new Error("loopback User URL required");
+const dataDir = resolve(dataArg);
+const runtimeDir = join(dataDir, "runtime");
+const info = await lstat(runtimeDir);
+if (
+  !info.isDirectory() ||
+  info.isSymbolicLink() ||
+  info.uid !== process.getuid() ||
+  info.mode & 0o077
+)
+  throw new Error("unsafe User runtime directory");
+const tokenPath = join(runtimeDir, "caller.token");
+const tokenInfo = await lstat(tokenPath);
+if (
+  !tokenInfo.isFile() ||
+  tokenInfo.isSymbolicLink() ||
+  tokenInfo.uid !== process.getuid() ||
+  tokenInfo.mode & 0o077
+)
+  throw new Error("unsafe caller credential");
+const token = (await readFile(tokenPath, "utf8")).trim();
+if (!/^[0-9a-f]{64}$/.test(token)) throw new Error("invalid caller credential");
+const checkpointName =
+  process.env.AGENTPAY_PROVIDER_NEGATIVE_CHECKPOINT ||
+  (mode === "silence" ? "silence-smoke.json" : "rejection-smoke.json");
+if (
+  ![
+    "silence-smoke.json",
+    "silence-crash-smoke.json",
+    "rejection-smoke.json",
+  ].includes(checkpointName) ||
+  (mode === "reject") !== (checkpointName === "rejection-smoke.json")
+)
+  throw new Error("invalid negative-case checkpoint name");
+const checkpointPath = join(runtimeDir, checkpointName);
+let checkpoint;
+try {
+  const checkpointInfo = await lstat(checkpointPath);
+  if (
+    !checkpointInfo.isFile() ||
+    checkpointInfo.isSymbolicLink() ||
+    checkpointInfo.uid !== process.getuid() ||
+    checkpointInfo.mode & 0o077
+  )
+    throw new Error("unsafe rejection checkpoint");
+  checkpoint = JSON.parse(await readFile(checkpointPath, "utf8"));
+} catch (error) {
+  if (error.code !== "ENOENT") throw error;
+  checkpoint = {
+    version:
+      mode === "reject"
+        ? "agentpay.rejection-smoke.v1"
+        : "agentpay.silence-smoke.v1",
+    key: randomUUID(),
+  };
+  const handle = await open(checkpointPath, "wx", 0o600);
+  try {
+    await handle.writeFile(`${JSON.stringify(checkpoint)}\n`);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+if (
+  checkpoint.version !==
+    (mode === "reject"
+      ? "agentpay.rejection-smoke.v1"
+      : "agentpay.silence-smoke.v1") ||
+  !/^[0-9a-f-]{36}$/.test(checkpoint.key)
+)
+  throw new Error("invalid negative-case checkpoint");
+
+const referenceFile = process.env.AGENTPAY_TEST_SERVICE_REFERENCE_FILE;
+if (!referenceFile)
+  throw Error(
+    "Set AGENTPAY_TEST_SERVICE_REFERENCE_FILE to the official public service reference",
+  );
+const serviceReference = JSON.parse(await readFile(referenceFile, "utf8"));
+const response = await fetch(new URL("/services/invoke", userUrl), {
+  method: "POST",
+  redirect: "error",
+  headers: {
+    "content-type": "application/json",
+    authorization: `Bearer ${token}`,
+    "idempotency-key": checkpoint.key,
+  },
+  body: JSON.stringify({
+    version: "agentpay.runtime-call.v1",
+    service: serviceReference,
+    request: { min: 10, max: 99 },
+    requestedMaxUsageUnits: "1",
+  }),
+  signal: AbortSignal.timeout(mode === "silence" ? 180_000 : 120_000),
+});
+const body = await response.json();
+const expectedCode =
+  mode === "silence" ? "PROVIDER_RECOVERY_TIMEOUT" : "PROVIDER_REJECTED";
+if (response.status !== 502 || body?.error?.code !== expectedCode) {
+  throw new Error(
+    `expected ${expectedCode}, got HTTP ${response.status} ${body?.error?.code || "UNKNOWN"}`,
+  );
+}
+const invocationId = `0x${createHash("sha256").update(`agentpay.user-invocation.v1:${checkpoint.key}`).digest("hex")}`;
+const document = JSON.parse(
+  await readFile(join(runtimeDir, "invocations.json"), "utf8"),
+);
+const invocation = document.invocations?.[invocationId];
+if (
+  !/^0x[0-9a-f]{64}$/.test(invocation?.orderId || "") ||
+  !invocation.paymentSubmitted ||
+  !/^0x[0-9a-f]{64}$/.test(invocation.orderRequestId || "")
+)
+  throw new Error("funded Order invocation checkpoint missing");
+process.stdout.write(
+  `${JSON.stringify(
+    {
+      ok: true,
+      orderId: invocation.orderId,
+      providerOutcome:
+        mode === "silence" ? "no_response_timeout" : "explicit_rejection",
+      sameKeyRecoverable: true,
+      paymentSubmitted: true,
+    },
+    null,
+    2,
+  )}\n`,
+);

package/scripts/renew.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 { renewPolicy } from "../src/renew-policy.mjs";
+if (process.argv.length !== 2) {
+  console.error("Usage: agentpay policy renew");
+  process.exitCode = 2;
+} else process.exitCode = await renewPolicy();

package/scripts/repair.mjs

@@ -0,0 +1,10 @@
+#!/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 { applyLocalUpdate } from "../src/local-update.mjs";
+const args = process.argv.slice(2);
+if (args.length > 1 || (args.length === 1 && args[0] !== "-f")) {
+  console.error("Usage: agentpay repair [-f]");
+  process.exitCode = 2;
+} else process.exitCode = await applyLocalUpdate({ force: args[0] === "-f" });

package/scripts/revoke.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 { revokePolicy } from "../src/renew-policy.mjs";
+if (process.argv.length !== 2) {
+  console.error("Usage: agentpay policy revoke");
+  process.exitCode = 2;
+} else process.exitCode = await revokePolicy();

package/scripts/select-skill-bundle.mjs

@@ -0,0 +1,39 @@
+#!/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 { confirmSkillAction } from "../src/skill-install-prompt.mjs";
+import {
+  inspectInstalledBundle,
+  selectInstalledBundle,
+} from "../src/active-skill.mjs";
+const [mode, data, directory] = process.argv.slice(2);
+if (
+  !["--preview", "--execute"].includes(mode) ||
+  !data ||
+  !directory ||
+  process.argv.length !== 5
+)
+  throw new Error(
+    "Usage: select-skill-bundle.mjs <--preview|--execute> DATA BUNDLE_DIRECTORY",
+  );
+const info = await inspectInstalledBundle(directory);
+const details = { ok: true, mode, ...info, orderCreated: false };
+if (mode === "--preview") console.log(JSON.stringify(details, null, 2));
+if (mode === "--execute") {
+  if (!process.stdin.isTTY || !process.stderr.isTTY)
+    throw new Error("SELECTION_TTY_REQUIRED");
+  console.log(
+    `Use this Skill in your local Runtime.\n${info.locallyModified ? "These files contain local edits. Review the details before confirming." : "Package files are unchanged since installation."}\nThis selects local files; it does not start a service or make a payment.`,
+  );
+  if (
+    !(await confirmSkillAction({
+      prompt:
+        "Type 'confirm' to select, 'details' to view file and service information, or 'q' to cancel: ",
+      details,
+    }))
+  )
+    throw new Error("SELECTION_NOT_CONFIRMED");
+  await selectInstalledBundle(data, directory, info.hashes);
+  console.log("Skill selected. Next: start and unlock Wallet / Runtime.");
+}

package/scripts/setup-local.mjs

@@ -0,0 +1,199 @@
+#!/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 { createInterface } from "node:readline/promises";
+import { rememberUserDataDir } from "../src/local-data-directory.mjs";
+// Minimal user-side setup for the private test. No Safe or policy action.
+import { spawn } from "node:child_process";
+import { lstat, mkdir, readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { initializeCallerCredential } from "../src/caller-auth.mjs";
+
+const command = process.argv[2];
+const dataDir = process.argv[3] ? resolve(process.argv[3]) : null;
+if (
+  !dataDir ||
+  !["install", "check"].includes(command) ||
+  !(
+    process.argv.length === 4 ||
+    (command === "install" &&
+      process.argv.length === 5 &&
+      process.argv[4] === "--restore")
+  )
+) {
+  throw new Error(
+    "usage: node user/scripts/setup-local.mjs <install|check> <private-data-dir>",
+  );
+}
+const walletDir = join(dataDir, "wallet");
+const runtimeDir = join(dataDir, "runtime");
+const credentialPath = join(runtimeDir, "caller.token");
+const keystore = join(walletDir, "session.keystore.json");
+const walletCli = walletCliPath();
+const userRuntime = fileURLToPath(new URL("../src/index.mjs", import.meta.url));
+for (const file of [walletCli, userRuntime]) await stat(file);
+
+async function privateDirectory(path) {
+  const info = await lstat(path);
+  if (
+    !info.isDirectory() ||
+    info.isSymbolicLink() ||
+    info.uid !== process.getuid() ||
+    (info.mode & 0o077) !== 0
+  )
+    throw new Error(
+      `private directory ownership or permissions invalid: ${path}`,
+    );
+}
+async function runWallet(...args) {
+  const child = spawn(process.execPath, [walletCli, ...args], {
+    stdio: "inherit",
+  });
+  const code = await new Promise((resolveExit, reject) => {
+    child.once("error", reject);
+    child.once("exit", (value) => resolveExit(value));
+  });
+  if (code !== 0)
+    throw new Error(`Wallet ${args[0]} failed with exit status ${code}`);
+}
+
+if (command === "install") {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    throw new Error(
+      "interactive terminal required for Wallet unlock-secret setup",
+    );
+  }
+  await mkdir(dataDir, { recursive: true, mode: 0o700 });
+  await privateDirectory(dataDir);
+  await mkdir(walletDir, { recursive: true, mode: 0o700 });
+  await mkdir(runtimeDir, { recursive: true, mode: 0o700 });
+  await privateDirectory(walletDir);
+  await privateDirectory(runtimeDir);
+  let exists = false;
+  try {
+    const info = await lstat(keystore);
+    if (!info.isFile() || info.isSymbolicLink())
+      throw new Error("Wallet keystore type invalid");
+    exists = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!exists) {
+    const ask = async (message) => {
+      const terminal = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+      });
+      try {
+        return (await terminal.question(message + "\n> ")).trim();
+      } finally {
+        terminal.close();
+      }
+    };
+    let choice =
+      process.argv[4] === "--restore"
+        ? "restore"
+        : await ask(
+            "Press Enter to create a new Wallet, type 'restore' to use your original key, or 'q' to return.",
+          );
+    while (!["", "restore", "q"].includes(choice))
+      choice = await ask(
+        "Enter 'restore', 'q', or press Enter for a new Wallet.",
+      );
+    if (choice === "q") process.exit(0);
+    if (choice === "restore") {
+      const source = await ask(
+        "Enter the path to your encrypted Session Key backup, or type 'key' to enter the original key privately ('q' to return).",
+      );
+      if (source === "q") process.exit(0);
+      if (!source) throw Error("A backup file path is required.");
+      await runWallet(
+        "import-key",
+        walletDir,
+        source === "key" ? "--private-key" : resolve(source),
+      );
+      process.stdout.write(
+        "Original Session Key restored. Spending permission is not bound yet.\n",
+      );
+    } else {
+      process.stdout.write(
+        "\nSet your Wallet unlock secret\n  Enter it twice; input is hidden.\n\n",
+      );
+      await runWallet("init", walletDir);
+    }
+    process.stdout.write(
+      `\nKeep your Wallet recoverable\n  Back up this encrypted file and keep its password:\n  ${keystore}\n  Never upload the backup to Market or share it with support.\n\n`,
+    );
+  }
+  try {
+    const info = await lstat(credentialPath);
+    if (
+      !info.isFile() ||
+      info.isSymbolicLink() ||
+      info.uid !== process.getuid() ||
+      (info.mode & 0o077) !== 0
+    )
+      throw new Error("existing caller credential type or permissions invalid");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  process.stdout.write(
+    "\nPrepare local runtime access\n  The next step creates or reuses a local access credential.\n  It is saved automatically; you do not need to copy it.\n\n",
+  );
+  await runWallet("prepare-access", walletDir);
+  await initializeCallerCredential(credentialPath);
+}
+
+await privateDirectory(dataDir);
+await privateDirectory(walletDir);
+await privateDirectory(runtimeDir);
+const credentialInfo = await lstat(credentialPath);
+if (
+  !credentialInfo.isFile() ||
+  credentialInfo.isSymbolicLink() ||
+  credentialInfo.uid !== process.getuid() ||
+  (credentialInfo.mode & 0o077) !== 0
+) {
+  throw new Error("User Runtime caller credential permissions invalid");
+}
+const token = (await readFile(credentialPath, "utf8")).trim();
+if (!/^[0-9a-f]{64}$/.test(token))
+  throw new Error("User Runtime caller credential invalid");
+const keystoreInfo = await lstat(join(walletDir, "session.keystore.json"));
+if (
+  !keystoreInfo.isFile() ||
+  keystoreInfo.isSymbolicLink() ||
+  keystoreInfo.uid !== process.getuid() ||
+  (keystoreInfo.mode & 0o077) !== 0
+) {
+  throw new Error("Wallet keystore permissions invalid");
+}
+const addressFile = JSON.parse(await readFile(keystore, "utf8"));
+const delegate = `0x${String(addressFile.address || "")}`;
+if (!/^0x[0-9a-fA-F]{40}$/.test(delegate))
+  throw new Error("Wallet keystore address invalid");
+let policyBoundLocalFile = false;
+try {
+  policyBoundLocalFile = (await lstat(join(walletDir, "policy.json"))).isFile();
+} catch (error) {
+  if (error.code !== "ENOENT") throw error;
+}
+if (command === "install") await rememberUserDataDir({ dataDir });
+process.stdout.write(
+  `${JSON.stringify(
+    {
+      ok: true,
+      installed: true,
+      dataDir,
+      wallet: { delegate, lockState: "not_checked", policyBoundLocalFile },
+      userRuntime: { callerCredential: "ready", running: "not_checked" },
+      readyToPurchase: false,
+      next: "confirm the existing-Safe spending policy",
+    },
+    null,
+    2,
+  )}\n`,
+);

package/scripts/status.mjs

@@ -0,0 +1,13 @@
+#!/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("status");
+} catch {
+  console.error(
+    "Could not check Wallet status. Check your local installation.",
+  );
+  process.exitCode = 1;
+}