callx402 1.0.1 → 1.0.3

package/test/intent-pipeline.test.js

@@ -16,8 +16,7 @@
 const { test } = require('node:test');
 const path = require('node:path');
 const { runIntent, runAction } = require('../core/index.js');
-const { scratchDir, withEnv } = require('./helpers');
-
+const { scratchDir, withEnv, needsV2Tree } = require('./helpers');
 const scratch = scratchDir('pipeline');
 const hermetic = {
   CALLX402_CONFIG: path.join(scratch, 'config.json'),
@@ -169,7 +168,7 @@ test('networks/assets/providers constrain planner, router and spendguard', async
   });
 });
 
-test('real end-to-end run (no doubles, all flags off): honest no-route', async (t) => {
+test('real end-to-end run (no doubles, all flags off): honest no-route', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const { result, exitCode } = await runIntent('summarize this for under 1 dollar', { maxBudget: 1 });
     t.assert.strictEqual(exitCode, 0);

package/test/payer-auth.test.js

@@ -0,0 +1,92 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { buildAuthMessage, actionRequestHash, readSignedAuthorization } = require('../core/payer-auth.js');
+const { invokeRail, isRailCommand } = require('../core/rail.js');
+
+const txHash = '0x' + '22'.repeat(32);
+const wallet = '0x' + '11'.repeat(20);
+const recipient = '0x' + '33'.repeat(20);
+const signature = '0x' + '44'.repeat(65);
+const authorization = () => ({
+  wallet, action: 'resolve', txHash, quote_id: 'q_test',
+  quote_inputs: { action: 'resolve', path: 'x402', issuedAt: 1 }, quoted_price_usd: '0.25',
+  request_hash: actionRequestHash('resolve', { evidence: '{}' }),
+  network: 'eip155:8453', recipient, nonce: 'nonce_unique_1234',
+  expiry: Math.floor(Date.now() / 1000) + 300, signature,
+});
+
+test('client and Rail use canonical EIP-191 signer message', () => {
+  const expected = [
+    'Payload x402 Authorization',
+    'wallet:' + wallet,
+    'action:resolve',
+    'txHash:' + txHash,
+    'quote_id:q_test',
+    'request_hash:' + authorization().request_hash,
+    'network:eip155:8453',
+    'recipient:' + recipient,
+    'nonce:nonce_unique_1234',
+    'expiry:' + authorization().expiry,
+  ].join('\n');
+  assert.equal(buildAuthMessage(authorization()), expected);
+});
+
+test('unsigned, malformed and expired authorizations are rejected before network payment', () => {
+  assert.throws(() => readSignedAuthorization('{}'), /wallet/);
+  const bad = { ...authorization(), expiry: Math.floor(Date.now()/1000) - 1 };
+  assert.throws(() => readSignedAuthorization(JSON.stringify(bad)), /expired/);
+});
+
+test('hosted CLI does not route local-only actions to paid Rail', () => {
+  assert.equal(isRailCommand('execute'), false);
+  assert.equal(isRailCommand('rescue'), false);
+  assert.equal(isRailCommand('resolve'), true);
+});
+
+test('signed noninteractive redemption sends signature, never wallet secrets', async () => {
+  const previous = global.fetch;
+  const requests = [];
+  global.fetch = async (url, init = {}) => {
+    requests.push({ url, init });
+    const quote = String(url).includes('/quote?');
+    const body = quote ? { quoted_price_usd: '0.25', quote_id: 'q_test', quote_inputs: { action: 'resolve', path: 'x402' } } :
+      { ok: true, invocation_id: 'invo_mock', via: 'x402', execution: { executed: true, result: { state: 'UNKNOWN' } } };
+    return { status: 200, text: async () => JSON.stringify(body) };
+  };
+  try {
+    const result = await invokeRail('resolve', {
+      evidence: '{}', txHash, payerAuth: JSON.stringify(authorization()),
+    }, { yes: true, json: true });
+    assert.equal(result.ok, true);
+    assert.equal(requests.length, 1);
+    const body = JSON.parse(requests[0].init.body);
+    assert.deepEqual(body.quote, authorization().quote_inputs);
+    assert.equal(body.txHash, txHash);
+    assert.equal(body.payer_auth.wallet, wallet);
+    assert.equal(body.payer_auth.signature, signature);
+    assert.equal(body.payer_auth.quote_id, 'q_test');
+    assert.equal('privateKey' in body, false);
+  } finally {
+    global.fetch = previous;
+  }
+});
+
+test('stale signature for a different quote fails without submitting a payment proof', async () => {
+  const previous = global.fetch;
+  const requests = [];
+  global.fetch = async (url, init = {}) => {
+    requests.push({ url, init });
+    return { status: 200, text: async () => JSON.stringify({ quoted_price_usd: '0.25', quote_id: 'q_changed', quote_inputs: { action: 'resolve', path: 'x402' } }) };
+  };
+  try {
+    const result = await invokeRail('resolve', {
+      txHash, payerAuth: JSON.stringify({ ...authorization(), action: 'recover' }),
+    }, { yes: true, json: true });
+    assert.equal(result.ok, false);
+    assert.match(result.error, /current quote/);
+    assert.equal(requests.length, 0);
+  } finally {
+    global.fetch = previous;
+  }
+});

package/test/remote.test.js

@@ -14,8 +14,7 @@ const { test } = require('node:test');
 const path = require('node:path');
 const { runAction, runIntent } = require('../core/index.js');
 const { createServer } = require('../server/index.js');
-const { scratchDir, cliEnv, runCLI, assertEnvelope, withEnv } = require('./helpers');
-
+const { scratchDir, cliEnv, runCLI, assertEnvelope, withEnv, needsV2Tree } = require('./helpers');
 const scratch = scratchDir('remote');
 
 /** Start a real callx402 server on an ephemeral port. */
@@ -148,7 +147,7 @@ test('remote auth: server with token rejects missing/wrong bearer, accepts the r
   }
 });
 
-test('remote money-safety: settlement UNKNOWN envelope crosses the wire unchanged (exit 5)', async (t) => {
+test('remote money-safety: settlement UNKNOWN envelope crosses the wire unchanged (exit 5)', needsV2Tree, async (t) => {
   // The server runs in-process, so the subsystem flag belongs to the parent
   // env; the CLI subprocess only carries the remote-mode config.
   await withEnv({ PAYLOAD_SETTLEMENT_RESOLVER: '1' }, async () => {

package/test/safety.test.js

@@ -15,8 +15,7 @@
 const { test } = require('node:test');
 const path = require('node:path');
 const { runIntent, runAction } = require('../core/index.js');
-const { scratchDir, cliEnv, runCLI, assertEnvelope, withEnv } = require('./helpers');
-
+const { scratchDir, cliEnv, runCLI, assertEnvelope, withEnv, needsV2Tree } = require('./helpers');
 const scratch = scratchDir('safety');
 const hermetic = {
   CALLX402_CONFIG: path.join(scratch, 'config.json'),
@@ -99,7 +98,7 @@ function walkPairs(o, prefix = '') {
   return out;
 }
 
-test('settlement UNKNOWN: exit 5, fail-closed, no retry/repay instruction', async (t) => {
+test('settlement UNKNOWN: exit 5, fail-closed, no retry/repay instruction', needsV2Tree, async (t) => {
   const r = await runCLI(
     ['resolve', '--evidence', '{}', '--json'],
     cliEnv(scratch, { PAYLOAD_SETTLEMENT_RESOLVER: '1' })
@@ -164,7 +163,7 @@ test('unsafe retry refusal: stored UNKNOWN + --force-retry -> refused, exit 5',
   });
 });
 
-test('unsafe retry refusal via real CLI + file-backed store', async (t) => {
+test('unsafe retry refusal via real CLI + file-backed store', needsV2Tree, async (t) => {
   const idemFile = path.join(scratch, 'idem-unsafe.jsonl');
   const env = cliEnv(scratch, { CALLX402_IDEMPOTENCY_FILE: idemFile });
   const seeded = {
@@ -222,7 +221,7 @@ test('timeout: slow subsystem + tiny timeoutMs -> timeout error, exit 1, no hang
   });
 });
 
-test('timeout via CLI --timeout: monitor --watch is cut off -> exit 1', async (t) => {
+test('timeout via CLI --timeout: monitor --watch is cut off -> exit 1', needsV2Tree, async (t) => {
   // --watch streams forever; --timeout 200ms must win the race and exit 1.
   const r = await runCLI(
     ['monitor', '--watch', '--interval', '50', '--timeout', '200'],

package/test/sdk.test.js

@@ -13,8 +13,7 @@
 const { test } = require('node:test');
 const path = require('node:path');
 const { execFile } = require('node:child_process');
-const { ENVELOPE_KEYS, scratchDir, withEnv } = require('./helpers');
-
+const { ENVELOPE_KEYS, scratchDir, withEnv, needsV2Tree } = require('./helpers');
 const scratch = scratchDir('sdk');
 const hermetic = {
   CALLX402_CONFIG: path.join(scratch, 'config.json'),
@@ -45,7 +44,7 @@ test('JS SDK: callx402({intent}) returns a full envelope (in-process)', async (t
   });
 });
 
-test('JS SDK: version, status(), and sub-actions', async (t) => {
+test('JS SDK: version, status(), and sub-actions', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     t.assert.strictEqual(sdk.version, '1.0.0');
     t.assert.strictEqual(require('../sdk/js/index.js').callx402.version, '1.0.0');
@@ -74,7 +73,7 @@ test('JS SDK: invalid opts throw TypeError (fail fast, no dispatch)', async (t)
   });
 });
 
-test('JS SDK: action dispatch through runAction', async (t) => {
+test('JS SDK: action dispatch through runAction', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const r = await sdk({ action: 'resolve', args: { evidence: '{}' } });
     // Settlement subsystem disabled without its flag: honest failure.

package/test/server.test.js

@@ -15,8 +15,7 @@ const { test } = require('node:test');
 const http = require('node:http');
 const path = require('node:path');
 const { createServer } = require('../server/index.js');
-const { ENVELOPE_KEYS, scratchDir, withEnv } = require('./helpers');
-
+const { ENVELOPE_KEYS, scratchDir, withEnv, needsV2Tree } = require('./helpers');
 // The in-process server's core reads the parent env: keep the idempotency
 // store hermetic for the whole file (each test file is its own process).
 const serverScratch = scratchDir('server');
@@ -59,7 +58,7 @@ function assertEnvelopeShape(t, env, action) {
   if (action !== undefined) t.assert.strictEqual(env.action, action);
 }
 
-test('GET /health -> 200 with version and subsystem map', async (t) => {
+test('GET /health -> 200 with version and subsystem map', needsV2Tree, async (t) => {
   const { server, port } = await startServer();
   try {
     const r = await request(port, 'GET', '/health');
@@ -134,7 +133,7 @@ test('unknown route -> 404', async (t) => {
   }
 });
 
-test('disabled subsystem over HTTP -> 503, honest envelope', async (t) => {
+test('disabled subsystem over HTTP -> 503, honest envelope', needsV2Tree, async (t) => {
   const { server, port } = await startServer();
   try {
     const r = await request(port, 'POST', '/resolve', { body: { evidence: {} } });
@@ -147,7 +146,7 @@ test('disabled subsystem over HTTP -> 503, honest envelope', async (t) => {
   }
 });
 
-test('settlement UNKNOWN over HTTP -> 409 with fail-closed envelope', async (t) => {
+test('settlement UNKNOWN over HTTP -> 409 with fail-closed envelope', needsV2Tree, async (t) => {
   await withEnv({ PAYLOAD_SETTLEMENT_RESOLVER: '1' }, async () => {
     const { server, port } = await startServer();
     try {

package/test/subsystems.test.js

@@ -12,8 +12,7 @@ const { test } = require('node:test');
 const path = require('node:path');
 const { runAction } = require('../core/index.js');
 const { getSubsystem } = require('../core/subsystems.js');
-const { assertEnvelope, scratchDir, withEnv } = require('./helpers');
-
+const { assertEnvelope, scratchDir, withEnv, needsV2Tree } = require('./helpers');
 const scratch = scratchDir('subsys');
 const hermetic = {
   CALLX402_CONFIG: path.join(scratch, 'config.json'),
@@ -26,7 +25,7 @@ function realModule(name) {
   return h.module;
 }
 
-test('rescue dispatch calls the real rescue module surface; no token -> auth_required exit 3', async (t) => {
+test('rescue dispatch calls the real rescue module surface; no token -> auth_required exit 3', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const { result, exitCode } = await runAction('rescue', { incident: 'inc-9' }, { deps: { rescue: realModule('rescue') } });
     t.assert.strictEqual(exitCode, 3);
@@ -36,7 +35,7 @@ test('rescue dispatch calls the real rescue module surface; no token -> auth_req
   });
 });
 
-test('rescue dispatch with --auth runs real triage (read-only)', async (t) => {
+test('rescue dispatch with --auth runs real triage (read-only)', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const { result, exitCode } = await runAction('rescue', { incident: 'inc-9', auth: true }, { deps: { rescue: realModule('rescue') } });
     t.assert.strictEqual(exitCode, 0);
@@ -47,7 +46,7 @@ test('rescue dispatch with --auth runs real triage (read-only)', async (t) => {
   });
 });
 
-test('doctor dispatch executes real runMcpDoctor and returns stages', async (t) => {
+test('doctor dispatch executes real runMcpDoctor and returns stages', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const { result, exitCode } = await runAction('diagnose', {}, { deps: { doctor: realModule('doctor') } });
     t.assert.strictEqual(exitCode, 0);
@@ -62,7 +61,7 @@ test('doctor dispatch executes real runMcpDoctor and returns stages', async (t)
   });
 });
 
-test('router dispatch runs real selectTool/rankTools over candidates', async (t) => {
+test('router dispatch runs real selectTool/rankTools over candidates', needsV2Tree, async (t) => {
   // The real smart-router asserts PAYLOAD_MCP_FABRIC=1 on rank/select.
   await withEnv({ ...hermetic, PAYLOAD_MCP_FABRIC: '1' }, async () => {
     const candidates = [
@@ -87,7 +86,7 @@ test('router dispatch runs real selectTool/rankTools over candidates', async (t)
   });
 });
 
-test('router dispatch honors the fast speed policy', async (t) => {
+test('router dispatch honors the fast speed policy', needsV2Tree, async (t) => {
   await withEnv({ ...hermetic, PAYLOAD_MCP_FABRIC: '1' }, async () => {
     const candidates = [
       { tool: 'cheap-slow', price_usd: 0.2, expected_latency_ms: 900 },
@@ -102,7 +101,7 @@ test('router dispatch honors the fast speed policy', async (t) => {
   });
 });
 
-test('settlement dispatch resolves real states (DEFINITELY_PAID evidence)', async (t) => {
+test('settlement dispatch resolves real states (DEFINITELY_PAID evidence)', needsV2Tree, async (t) => {
   await withEnv(hermetic, async () => {
     const settlement = realModule('settlement');
     const probe = settlement.resolve({ txHash: '0x' + 'ab'.repeat(32), confirmations: 12, expectedAmount: '1.00', actualAmount: '1.00', asset: 'USDC' });

package/test/veyline-commands.test.js

@@ -0,0 +1,193 @@
+'use strict';
+
+/**
+ * test/veyline-commands.test.js — ADDITIVE test for the Veyline Recovery
+ * track commands: evidence, explain, recover.
+ *
+ * Does not touch existing commands. Uses core.runAction directly with a
+ * temp --dir so no fixture pollutes the repo. Saves/restores env flags.
+ */
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { runAction, ACTIONS } = require('../core/index');
+
+const FLAGS = ['PAYLOAD_VEYLINE_LEDGER', 'PAYLOAD_VEYLINE_RECOVERY'];
+let saved = {};
+
+function envOn() {
+  saved = {};
+  for (const f of FLAGS) { saved[f] = process.env[f]; process.env[f] = '1'; }
+}
+function envOff() {
+  for (const f of FLAGS) {
+    if (saved[f] === undefined) delete process.env[f];
+    else process.env[f] = saved[f];
+  }
+}
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'callx402-veyline-'));
+}
+
+// Local-mode gate: the veyline tree is the optional advanced self-hosted
+// runtime, not a requirement. On a clean machine (no tree) the tree-dependent
+// tests skip — the CLI routes to the hosted rail by default instead.
+const VEYLINE_ROOT = path.resolve(__dirname, '..', '..', 'veyline', 'engineering', 'recovery');
+let treeAvailable = false;
+try { require(path.join(VEYLINE_ROOT, 'operation-ledger.js')); treeAvailable = true; } catch { treeAvailable = false; }
+const needsTree = { skip: !treeAvailable };
+
+function seedLedger(dir) {
+  // Seed through the real veyline modules so recover() can hit the cache.
+  const root = path.resolve(__dirname, '..', '..', 'veyline', 'engineering', 'recovery');
+  const L = require(path.join(root, 'operation-ledger.js'));
+  const R = require(path.join(root, 'recovery-state.js'));
+  const ledger = L.createOperationLedger({ dir });
+  ledger.record({ operationId: 'op_cli1', kind: 'begin', protocol: 'x402', actor: 'client', summary: 'begins' });
+  ledger.record({ operationId: 'op_cli1', kind: 'payment', protocol: 'x402', actor: 'fac', summary: 'settled', states: { payment: 'SETTLED' } });
+  ledger.record({ operationId: 'op_cli1', kind: 'execution', protocol: 'MCP', actor: 'prov', summary: 'done', states: { execution: 'SUCCEEDED' } });
+  ledger.record({ operationId: 'op_cli1', kind: 'delivery', protocol: 'MCP', actor: 'prov', summary: 'lost', states: { delivery: 'LOST' } });
+  const cache = R.createFileBackedCache({ file: path.join(dir, 'recovery-cache.jsonl') });
+  const net = R.createRecoveryNetwork({ ledger, cache });
+  const stored = net.storeSettledResult({
+    toolName: 't', args: {}, payer: 'payer_1', paymentAuthFingerprint: 'fp1',
+    operationId: 'op_cli1', result: { ok: true }, settlementTx: '0x1',
+  });
+  return stored.identity;
+}
+
+test('ACTIONS includes the three new commands and no existing command was removed', () => {
+  for (const c of ['diagnose', 'rescue', 'route', 'resolve', 'doctor', 'execute', 'monitor', 'status', 'preflight', 'inspect',
+    'evidence', 'explain', 'recover']) {
+    assert.ok(ACTIONS.includes(c), `ACTIONS missing ${c}`);
+  }
+});
+
+test('evidence: reports recorded events for a known operation', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    seedLedger(dir);
+    const { result, exitCode } = await runAction('evidence', { operationId: 'op_cli1', dir }, {});
+    assert.equal(exitCode, 0);
+    assert.equal(result.ok, true);
+    assert.equal(result.action, 'evidence');
+    assert.equal(result.data.operationId, 'op_cli1');
+    assert.ok(result.data.eventCount >= 4);
+    assert.equal(result.data.states.payment, 'SETTLED');
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('evidence: unknown operation is honest no_basis, still exit 0', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    const { result, exitCode } = await runAction('evidence', { operationId: 'op_nope', dir }, {});
+    assert.equal(exitCode, 0);
+    assert.equal(result.ok, true);
+    assert.match(result.data.basis, /no_basis/);
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('evidence: disabled flag -> exit 3, nothing executed', needsTree, async () => {
+  envOff();
+  const { result, exitCode } = await runAction('evidence', { operationId: 'x', dir: tmpDir() }, {});
+  assert.equal(exitCode, 3);
+  assert.equal(result.ok, false);
+  assert.equal(result.error.code, 'subsystem_disabled');
+});
+
+test('explain: plain-language assessment of an operation', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    seedLedger(dir);
+    const { result, exitCode } = await runAction('explain', { operationId: 'op_cli1', dir }, {});
+    assert.equal(exitCode, 0);
+    assert.ok(result.disposition.includes('op_cli1'));
+    assert.ok(result.data.assessment.length > 0);
+    assert.ok(Array.isArray(result.data.trail));
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('explain: missing operationId -> usage error', needsTree, async () => {
+  envOn();
+  try {
+    const { result, exitCode } = await runAction('explain', {}, {});
+    assert.equal(exitCode, 2);
+    assert.equal(result.error.code, 'usage');
+  } finally { envOff(); }
+});
+
+test('recover: RECOVERABLE decision returned read-only with the prior result', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    const identity = seedLedger(dir);
+    const { result, exitCode } = await runAction('recover', {
+      operationId: 'op_cli1', dir, identity,
+      evidence: JSON.stringify({ payer: 'payer_1', paymentAuthFingerprint: 'fp1' }),
+    }, {});
+    assert.equal(exitCode, 0);
+    assert.equal(result.data.decision.recoveryState, 'RECOVERABLE');
+    assert.equal(result.data.terminal, 'KNOWN_SAFE');
+    assert.deepEqual(result.data.decision.result, { ok: true });
+    assert.match(result.disposition, /Read-only/);
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('recover: builds the identity from evidence fields when --identity is absent', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    seedLedger(dir); // seeds toolName 't', args {}, payer payer_1, fp1, no traceId
+    const { result, exitCode } = await runAction('recover', {
+      operationId: 'op_cli1', dir,
+      evidence: JSON.stringify({ toolName: 't', args: {}, payer: 'payer_1', paymentAuthFingerprint: 'fp1' }),
+    }, {});
+    assert.equal(exitCode, 0);
+    assert.equal(result.data.decision.recoveryState, 'RECOVERABLE');
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('recover: unknown identity with no evidence -> SETTLEMENT_UNKNOWN, never a repay', needsTree, async () => {
+  envOn();
+  const dir = tmpDir();
+  try {
+    const { result, exitCode } = await runAction('recover', {
+      operationId: 'op_cli1', dir, identity: 'opid_unknown',
+      evidence: JSON.stringify({ payer: 'payer_1', paymentAuthFingerprint: 'fp1' }),
+    }, {});
+    assert.equal(exitCode, 0);
+    assert.equal(result.data.decision.recoveryState, 'SETTLEMENT_UNKNOWN');
+    assert.equal(result.data.terminal, 'HUMAN_REVIEW');
+    assert.ok(result.data.decision.actionsForbidden.includes('blind_repay'));
+  } finally { envOff(); fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('recover: missing identity and insufficient evidence fields -> usage error', needsTree, async () => {
+  envOn();
+  try {
+    const { result, exitCode } = await runAction('recover', { operationId: 'op_cli1', dir: tmpDir() }, {});
+    assert.equal(exitCode, 2);
+    assert.equal(result.error.code, 'usage');
+  } finally { envOff(); }
+});
+
+test('recover: disabled flag -> exit 3', needsTree, async () => {
+  envOff();
+  const { result, exitCode } = await runAction('recover', { operationId: 'x', identity: 'y' }, {});
+  assert.equal(exitCode, 3);
+  assert.equal(result.error.code, 'subsystem_disabled');
+});
+
+test('existing commands still dispatch: unknown command lists the new commands too', async () => {
+  const { result, exitCode } = await runAction('frobnicate', {}, {});
+  assert.equal(exitCode, 2);
+  assert.ok(result.data.commands.includes('evidence'));
+  assert.ok(result.data.commands.includes('recover'));
+});