@ola-893/agentpay-cli 0.1.0 → 0.2.0

package/src/settings.mjs

@@ -0,0 +1,101 @@
+import { resolve, join } from 'node:path';
+import { mkdir, open, unlink } from 'node:fs/promises';
+import { liveProfile } from './config.mjs';
+import { atomicWrite, readOptional } from './files.mjs';
+import { readConfig, readKey } from '@ola-893/agentpay-core/internal-config';
+import { runtimePolicy, serviceConfig } from '@ola-893/agentpay-core/internal-runtime-policy';
+import { inspectNearProfile, NearAgentPayClient } from '@ola-893/agentpay-core/near';
+
+export function usdc(value) {
+  if (typeof value !== 'string' || !/^(0|[1-9][0-9]{0,24})(\.[0-9]{1,6})?$/.test(value)) throw new Error('Use a nonnegative USDC amount with at most six decimal places.');
+  const [whole, fraction = ''] = value.split('.');
+  return (BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, '0'))).toString();
+}
+export async function settings(project) {
+  const profile = await liveProfile(project);
+  return { profile, config: await readConfig(profile.configPath) };
+}
+export async function showSettings(project) {
+  const { profile, config } = await settings(project);
+  const { client, summary } = await inspectNearProfile(profile.configPath, profile.stateRoot);
+  return { network: config.network, vaultId: config.vaultId, agentId: config.agentId, recipientId: config.recipientId, paymentsEnabled: profile.paymentsEnabled,
+    financialPolicy: (await client.getVault()).policy, financialUnits: 'raw USDC (1 USDC = 1000000)', runtimePolicy: config.runtimePolicy,
+    service: { url: config.serviceUrl, ...config.service }, inference: profile.inference || null, ...summary };
+}
+export async function setRuntime(project, patch) {
+  if (!Object.keys(patch).length) throw new Error('Specify at least one runtime guardrail. See --help.');
+  const { profile, config } = await settings(project);
+  config.runtimePolicy = runtimePolicy({ ...config.runtimePolicy, ...patch });
+  await atomicWrite(profile.configPath, JSON.stringify(config, null, 2));
+  return { runtimePolicy: config.runtimePolicy, enforcement: 'local payment worker; thresholds reload on the next checkpoint', restartRequired: 'Restart running agents/MCP servers after changing reuse, polling or exit behavior.' };
+}
+export async function setService(project, patch) {
+  const { profile, config } = await settings(project);
+  const { summary, client } = await inspectNearProfile(profile.configPath, profile.stateRoot);
+  if (summary.activeSession || summary.pendingIntent || summary.executorBusyOrInterrupted) throw new Error('CLOSE_OR_RECONCILE_STREAM_BEFORE_SERVICE_CHANGE');
+  const { url, recipient, ...paths } = patch;
+  const next = { ...config, serviceUrl: url || config.serviceUrl, recipientId: recipient || config.recipientId, service: serviceConfig({ ...config.service, ...paths }) };
+  const temp = profile.configPath + '.candidate.json';
+  await atomicWrite(temp, JSON.stringify(next));
+  let validated;
+  try { validated = await readConfig(temp); } finally { await unlink(temp); }
+  if (!(await client.getVault()).policy.recipients.includes(validated.recipientId)) throw new Error('RECIPIENT_NOT_IN_ONCHAIN_POLICY');
+  await atomicWrite(profile.configPath, JSON.stringify(validated, null, 2));
+  return { service: { url: validated.serviceUrl, recipient: validated.recipientId, ...validated.service }, restartRequired: 'Restart running agents/MCP servers after service changes.' };
+}
+export function inferenceConfig(input) {
+  if (!input || typeof input.model !== 'string' || !input.model.trim() || input.model.length > 256) throw new Error('Provide --model.');
+  const url = new URL(input.baseUrl);
+  if (url.username || url.password || url.search || url.hash || !(url.protocol === 'https:' || (url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname)))) throw new Error('Inference URL must use HTTPS or loopback without embedded credentials.');
+  if (input.apiKeyEnv && !/^[A-Z][A-Z0-9_]{0,127}$/.test(input.apiKeyEnv)) throw new Error('Provide an environment variable NAME via --api-key-env, never the key itself.');
+  const maxSteps = input.maxSteps ?? 12;
+  if (!Number.isInteger(maxSteps) || maxSteps < 1 || maxSteps > 100) throw new Error('maxSteps must be between 1 and 100.');
+  if (input.thinking !== undefined && typeof input.thinking !== 'boolean') throw new Error('thinking must be true or false.');
+  return { protocol: 'openai-chat', baseUrl: url.href.replace(/\/$/, ''), model: input.model, ...(input.apiKeyEnv ? { apiKeyEnv: input.apiKeyEnv } : {}), ...(input.thinking !== undefined ? { thinking: input.thinking } : {}), maxSteps };
+}
+export async function setInference(project, input) {
+  const profile = await liveProfile(project);
+  const inference = inferenceConfig(input);
+  const { file, configPath, stateRoot, ...saved } = profile;
+  await atomicWrite(file, JSON.stringify({ ...saved, inference }, null, 2));
+  return { inference, credentialsStored: false, next: 'agentpay agent run --prompt "Use the configured paid API to answer my question."' };
+}
+export async function setLimits(project, patch, ownerKeyFile) {
+  if (!ownerKeyFile) throw new Error('--owner-key is required for an on-chain policy change; it is never saved in the agent profile.');
+  if (!Object.keys(patch).length) throw new Error('Specify at least one financial limit.');
+  const { profile, config } = await settings(project);
+  const { client: reader, stateDir } = await inspectNearProfile(profile.configPath, profile.stateRoot);
+  const owner = await readKey(resolve(ownerKeyFile));
+  if (owner.accountId !== config.ownerId) throw new Error('OWNER_CREDENTIAL_MISMATCH');
+  const client = new NearAgentPayClient({ vaultId: config.vaultId, accountId: owner.accountId, privateKey: owner.privateKey, rpcUrl: config.rpcUrl });
+  await mkdir(stateDir, { recursive: true, mode: 0o700 });
+  const lock = await open(join(stateDir, 'operation.lock'), 'wx', 0o600);
+  try {
+    if (await readOptional(join(stateDir, 'pending.json'))) throw new Error('RECONCILIATION_REQUIRED');
+    const vault = await reader.getVault();
+    if (vault.active_session) throw new Error('CLOSE_STREAM_BEFORE_POLICY_CHANGE');
+    const policy = { ...vault.policy, ...patch };
+    if (BigInt(policy.budget) < BigInt(vault.spent) || BigInt(policy.max_deposit) <= 0n || BigInt(policy.max_deposit) > BigInt(policy.budget) || BigInt(policy.max_rate) <= 0n || !Number.isInteger(policy.max_duration_seconds) || policy.max_duration_seconds < 1 || policy.max_duration_seconds > 3600 || !policy.recipients.includes(config.recipientId) || policy.recipients.length > 32 || policy.recipients.some(id => !/^[a-z0-9]+(?:[-_.][a-z0-9]+)*$/.test(id) || id.length < 2 || id.length > 64)) throw new Error('INVALID_FINANCIAL_POLICY');
+    const pending = join(stateDir, 'policy-pending.json');
+    const journal = await open(pending, 'wx', 0o600);
+    try { await journal.writeFile(JSON.stringify({ policy, vaultId: config.vaultId, nonceBefore: vault.next_nonce, createdAt: new Date().toISOString() })); await journal.sync(); } finally { await journal.close(); }
+    const receipt = await client.execute('configure', { policy });
+    await atomicWrite(join(stateDir, `policy-${receipt.hash}.receipt.json`), JSON.stringify(receipt));
+    const actual = (await reader.getVault()).policy;
+    if (JSON.stringify(actual) !== JSON.stringify(policy)) throw new Error('POLICY_RECONCILIATION_REQUIRED');
+    await unlink(pending);
+    return { financialPolicy: actual, units: 'raw USDC', transactionHash: receipt.hash, explorerUrl: `https://testnet.nearblocks.io/txns/${receipt.hash}` };
+  } finally { await lock.close(); await unlink(join(stateDir, 'operation.lock')); }
+}
+export async function reconcileLimits(project) {
+  const { profile } = await settings(project);
+  const { client, stateDir } = await inspectNearProfile(profile.configPath, profile.stateRoot);
+  const file = join(stateDir, 'policy-pending.json');
+  const text = await readOptional(file);
+  if (!text) return { resolved: true, reason: 'NO_PENDING_POLICY' };
+  const pending = JSON.parse(text), vault = await client.getVault(), actual = vault.policy;
+  if (JSON.stringify(actual) !== JSON.stringify(pending.policy) || pending.nonceBefore === undefined || BigInt(vault.next_nonce) <= BigInt(pending.nonceBefore)) return { resolved: false, reason: 'POLICY_OUTCOME_UNCONFIRMED' };
+  await atomicWrite(file.replace('.json', '.reconciled.json'), JSON.stringify({ ...pending, verifiedAt: new Date().toISOString() }));
+  await unlink(file);
+  return { resolved: true, financialPolicy: actual, receiptRecovered: false };
+}

package/src/setup.mjs

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { mkdir, readFile, stat, open, unlink } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { JsonRpcProvider } from 'near-api-js';
+import { configHome, initProject, liveProfile } from './config.mjs';
+import { atomicWrite, readOptional, safeTarget } from './files.mjs';
+import { readKey, readConfig } from '@ola-893/agentpay-core/internal-config';
+import { NearAgentPayClient } from '@ola-893/agentpay-core/near';
+import { deployTestnet } from '@ola-893/agentpay-core/internal-deployment';
+
+const setupId = project => createHash('sha256').update(project).digest('hex');
+export const bundledWasm = fileURLToPath(new URL('../artifacts/agentpay_vault.wasm', import.meta.url));
+export const publicRecording = fileURLToPath(new URL('../ui/near/testnet.json', import.meta.url));
+
+export async function setupTestnet(project, options) {
+  if (!options.ownerId || !options.ownerKeyFile) return {
+    status: 'OWNER_SETUP_REQUIRED', network: 'testnet', signedTransactions: 0,
+    next: 'agentpay init --network testnet --owner-id YOUR.testnet --owner-key /absolute/path/owner.json',
+    steps: ['Create/export a named NEAR testnet owner account using your wallet or near-cli-rs. Keep its Ed25519 credential JSON private (0600).', 'Fund it with at least 6 test NEAR after storage reserve. The setup creates a vault and restricted agent; recipient defaults to the owner for the local fixture.', 'Run the command above for read-only preflight, then add --deploy to submit setup transactions. No deployment.json or Rust build is required.', 'After setup, use the Circle faucet (Near Testnet) for the printed owner address, then agentpay fund --amount 100000 --owner-key /absolute/path/owner.json.', 'Run Configure the service, inference and financial/runtime guardrails, then enable payments and run agentpay agent run --prompt "...".'],
+    nearAccounts: 'https://docs.near.org/tools/cli', usdcFaucet: 'https://faucet.circle.com/',
+    noSponsor: true,
+  };
+  const { deploymentPlan, inspectTestnet } = await import('@ola-893/agentpay-core/internal-preflight');
+  const key = await readKey(resolve(options.ownerKeyFile));
+  if (key.accountId !== options.ownerId) throw new Error('OWNER_CREDENTIAL_MISMATCH');
+  const plan = deploymentPlan({ ownerId: options.ownerId, recipientId: options.recipientId || options.ownerId, vaultLabel: options.vaultLabel, agentLabel: options.agentLabel, rpcUrl: options.rpcUrl, serviceUrl: options.serviceUrl });
+  const provider = new JsonRpcProvider({ url: plan.rpcUrl });
+  const preflight = await inspectTestnet(plan, { provider, readWasm: () => readFile(bundledWasm), ownerPublicKey: key.publicKey });
+  if (!options.deploy) return { ...preflight, next: preflight.readyToDeploy ? 'Repeat this init command with --deploy. Setup uses up to 6 test NEAR, installs owner-controlled vault/admin keys, and does not fund USDC or enable payments.' : 'Resolve the reported checks, then repeat init. No transaction was signed.' };
+  if (!preflight.readyToDeploy) throw new Error('TESTNET_PREFLIGHT_FAILED: ' + preflight.checks.filter(c => c.status !== 'pass').map(c => `${c.id}: ${c.detail}`).join('; '));
+  const home = configHome();
+  await mkdir(home, { recursive: true, mode: 0o700 });
+  if (((await stat(home)).mode & 0o077) !== 0) throw new Error('AGENTPAY_HOME must have permissions 0700.');
+  const directory = await safeTarget(home, join('setups', setupId(project)));
+  const configPath = join(directory, 'deployment.json');
+  if (await readOptional(await safeTarget(project, '.agentpay/config.json'))) throw new Error('PROJECT_ALREADY_INITIALIZED');
+  const result = await deployTestnet({ ...plan, ownerKeyFile: resolve(options.ownerKeyFile), vaultLabel: options.vaultLabel, agentLabel: options.agentLabel, directory, wasmFile: bundledWasm, onProgress: event => process.stderr.write(`NEAR setup ${event.step}: ${event.transactionHash}\n`) });
+  await initProject(project, { deployment: configPath });
+  return {
+    status: 'DEPLOYED', network: 'testnet', ownerId: result.config.ownerId, vaultId: result.config.vaultId, agentId: result.config.agentId, recipientId: result.config.recipientId,
+    paymentsEnabled: false, ownerUSDCFundingAddress: result.config.ownerId, usdcFaucet: 'https://faucet.circle.com/',
+    transactions: result.record.steps.map(s => ({ step: s.name, hash: s.hash, explorerUrl: `https://testnet.nearblocks.io/txns/${s.hash}` })),
+    privateSetupDirectory: directory, next: 'Get Circle test USDC for the owner (Near Testnet). Then agentpay fund --amount 100000 --owner-key /absolute/path/owner.json. Owner/admin setup credentials are kept separately from the runtime profile.',
+  };
+}
+
+export async function fundProject(project, { ownerKeyFile, amount }) {
+  if (!/^[1-9][0-9]{0,20}$/.test(amount ?? '') || BigInt(amount) > 100000n) throw new Error('Provide --amount in raw six-decimal USDC units, at most 100000 (0.1 test USDC) per funding call.');
+  if (!ownerKeyFile) throw new Error('--owner-key is required only for this explicit funding operation.');
+  const profile = await liveProfile(project);
+  const config = await readConfig(profile.configPath);
+  const owner = await readKey(resolve(ownerKeyFile));
+  if (owner.accountId !== config.ownerId) throw new Error('OWNER_CREDENTIAL_MISMATCH');
+  const provider = new JsonRpcProvider({ url: config.rpcUrl });
+  if ((await provider.viewNodeStatus()).chain_id !== 'testnet') throw new Error('RPC_NETWORK_MISMATCH');
+  const accessKey = await provider.viewAccessKey({ accountId: config.ownerId, publicKey: owner.publicKey, blockQuery: { finality: 'final' } });
+  if (accessKey.permission !== 'FullAccess') throw new Error('OWNER_FULL_ACCESS_REQUIRED');
+  const client = new NearAgentPayClient({ vaultId: config.vaultId, accountId: owner.accountId, privateKey: owner.privateKey, provider });
+  const vault = await client.getVault();
+  if (vault.owner_id !== owner.accountId || vault.token_id !== config.tokenId) throw new Error('VAULT_IDENTITY_MISMATCH');
+  if (BigInt(await client.tokenBalance(owner.accountId, config.tokenId)) < BigInt(amount)) throw new Error(`OWNER_USDC_INSUFFICIENT: request Near Testnet USDC at https://faucet.circle.com/ for ${owner.accountId}`);
+  const pending = join(configHome(), 'funding', createHash('sha256').update(config.vaultId).digest('hex') + '.json');
+  await mkdir(join(configHome(), 'funding'), { recursive: true, mode: 0o700 });
+  let journal;
+  try { journal = await open(pending, 'wx', 0o600); } catch (e) { if (e.code === 'EEXIST') throw new Error(`FUNDING_RECONCILIATION_REQUIRED: inspect ${pending}. No transaction was resubmitted.`); throw e; }
+  try { await journal.writeFile(JSON.stringify({ network: config.network, vaultId: config.vaultId, ownerId: owner.accountId, amount, createdAt: new Date().toISOString() })); await journal.sync(); } finally { await journal.close(); }
+  const receipt = await client.fund(amount);
+  await atomicWrite(pending.replace('.json', `-${receipt.hash}.receipt.json`), JSON.stringify(receipt));
+  if (receipt.receiptFailures.length || receipt.value !== amount) throw new Error(`FUNDING_NOT_CONFIRMED: ${receipt.hash}; inspect ${pending}.`);
+  await unlink(pending);
+  return { network: 'testnet', amountRawUSDC: amount, transactionHash: receipt.hash, explorerUrl: `https://testnet.nearblocks.io/txns/${receipt.hash}`, next: 'agentpay config show; configure service/inference and guardrails, then agentpay payments --enable and agentpay agent run --prompt "..."' };
+}

package/src/ui.mjs

@@ -3,11 +3,15 @@ import { readFile, realpath } from 'node:fs/promises';
 import { resolve, extname, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
+import { verifyRun } from '@ola-893/agentpay-core/internal-evidence-audit';
 
 const uiRoot = fileURLToPath(new URL('../ui/', import.meta.url));
 const mime = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8', '.json': 'application/json', '.svg': 'image/svg+xml', '.png': 'image/png', '.woff2': 'font/woff2', '.ico': 'image/x-icon' };
 export async function startUi({ port = 0, recording = 'testnet' } = {}) {
   if (!['testnet', 'sandbox'].includes(recording)) throw new Error('Choose --recording testnet or sandbox.');
+  const captured = JSON.parse(await readFile(resolve(uiRoot, 'near', `${recording}.json`), 'utf8'));
+  verifyRun(captured);
+  if (captured.network !== recording || captured.simulated) throw new Error('REPLAY_PROVENANCE_MISMATCH');
   const server = createServer(async (req, res) => {
     const send = (status, body, type = 'text/plain') => {
       res.writeHead(status, { 'content-type': type, 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', 'x-frame-options': 'DENY', 'referrer-policy': 'no-referrer' });