callx402 1.0.0 → 1.0.2

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'));
+});