dexbot 1.4.20 → 1.4.22

package/claw/tests/test_claw_bridge.ts

@@ -1,18 +1,16 @@
 'use strict';
 
 const assert = require('assert');
+const { runEsmMockStages, defineEsmMockAbs } = require('../../tests/helpers/esm_mocks');
 
-function clearModule(modulePath: string) {
-  delete require.cache[modulePath];
+// Compiled ESM graphs cannot be mocked via require.cache; the helper installs
+// loader hooks (one child process per stage so fresh module instances load).
+function clearModule(_modulePath: string) {
+  /* no-op under ESM hooks */
 }
 
 function registerMock(modulePath: string, exports: any) {
-  require.cache[modulePath] = {
-    id: modulePath,
-    filename: modulePath,
-    loaded: true,
-    exports
-  } as any;
+  defineEsmMockAbs(modulePath, Object.keys(exports), exports);
 }
 
 function createBridgeHarness() {
@@ -225,6 +223,30 @@ function createBridgeHarness() {
     }
   });
 
+  // The mock replicates the real validator's required-args table: under ESM
+  // hooks the real module cannot be require()d here (that would bypass the
+  // mock and poison the module cache with the real instance).
+  const memuRequiredArgs = {
+    'memorize': { groups: [['resourceUrl'], ['modality']], message: 'memorize requires resourceUrl and modality' },
+    'retrieve': { groups: [['queries']], message: 'retrieve requires queries' },
+    'create-item': { groups: [['categoryId', 'categoryName', 'category'], ['summary']], message: 'create-item requires categoryId or categoryName, plus summary' },
+    'update-item': { groups: [['itemId'], ['updates']], message: 'update-item requires itemId and updates' },
+    'delete-item': { groups: [['itemId']], message: 'delete-item requires itemId' },
+    'memorize-conversation': { groups: [['messages']], message: 'memorize-conversation requires messages array' },
+    'memorize-trading-context': { groups: [['context']], message: 'memorize-trading-context requires context' },
+    'retrieve-trading-context': { groups: [['query']], message: 'retrieve-trading-context requires query' }
+  };
+  function validateMemuCommandArgs(command: string, options: any) {
+    const spec = (memuRequiredArgs as any)[command];
+    if (!spec) return;
+    const satisfied = spec.groups.every(
+      (group: string[]) => group.some((field) => options[field])
+    );
+    if (!satisfied) {
+      throw new Error(spec.message);
+    }
+  }
+
   registerMock(memuBridgePath, {
     describeMemuBridge: (options: any) => ({
       options,
@@ -238,7 +260,8 @@ function createBridgeHarness() {
         options,
         source: 'memu'
       };
-    }
+    },
+    validateMemuCommandArgs
   });
 
   clearModule(bridgePath);
@@ -499,7 +522,7 @@ async function testRunClawCommandDispatchMatrix() {
       () => bridge.runClawCommand('memu-create-item', {
         summary: 'missing category'
       }),
-      /memu-create-item requires categoryId or categoryName, plus summary/
+      /create-item requires categoryId or categoryName, plus summary/
     );
 
     await assert.rejects(
@@ -531,12 +554,17 @@ async function testRunClawCommandDispatchMatrix() {
   console.log('    PASS');
 }
 
-async function main() {
-  await testCreateClawBridgeSanitizesPrivateKey();
-  await testRunClawCommandDispatchMatrix();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+runEsmMockStages(
+  ['sanitizes-private-key', 'dispatch-matrix'],
+  async (stage: string) => {
+    if (stage === 'sanitizes-private-key') {
+      await testCreateClawBridgeSanitizesPrivateKey();
+      return;
+    }
+    if (stage === 'dispatch-matrix') {
+      await testRunClawCommandDispatchMatrix();
+      return;
+    }
+    throw new Error(`Unknown stage: ${stage}`);
+  }
+);

package/claw/tests/test_claw_catalog_and_credentials.ts

@@ -54,8 +54,8 @@ function testClawCatalog() {
   catalogCopy[0].command = 'mutated';
   assert.notStrictEqual(catalog.getClawToolCatalog()[0].command, 'mutated');
 
-  const examples = catalog.buildClawCommandExamples('tsx scripts/claw_bridge.ts');
-  assert.ok(examples.some((line: any) => line.startsWith('tsx scripts/claw_bridge.ts manifest')));
+  const examples = catalog.buildClawCommandExamples('node dist/claw/scripts/claw_bridge.js');
+  assert.ok(examples.some((line: any) => line.startsWith('node dist/claw/scripts/claw_bridge.js manifest')));
   assert.ok(examples.some((line: any) => line.includes('bot-settings-apply')));
 }
 
@@ -134,9 +134,13 @@ async function testCredentialDaemonClient() {
 
 function testDexbotBridgeRootResolution() {
   const bridge = require('../modules/dexbot_bridge');
-  const expectedRoot = path.resolve(__dirname, '..', '..');
+  const root = bridge.getDexbot2Root();
 
-  assert.strictEqual(bridge.getDexbot2Root(), expectedRoot);
+  // The resolved root must be a real DEXBot2 checkout that contains this
+  // test's compiled location and the module tree the bridge resolves against.
+  const rel = path.relative(root, __dirname);
+  assert.ok(!rel.startsWith('..') && !path.isAbsolute(rel), 'resolved DEXBot2 root must contain this test');
+  assert.ok(fs.existsSync(path.join(root, 'package.json')), 'resolved DEXBot2 root must contain package.json');
 }
 
 async function main() {

package/claw/tests/test_claw_chain_layer.ts

@@ -1,18 +1,16 @@
 'use strict';
 
 const assert = require('assert');
+const { runEsmMockStages, defineEsmMockAbs } = require('../../tests/helpers/esm_mocks');
 
-function clearModule(modulePath: string) {
-  delete require.cache[modulePath];
+// Compiled ESM graphs cannot be mocked via require.cache; the helper installs
+// loader hooks (one child process per stage so fresh module instances load).
+function clearModule(_modulePath: string) {
+  /* no-op under ESM hooks */
 }
 
 function registerMock(modulePath: string, exports: any) {
-  require.cache[modulePath] = {
-    id: modulePath,
-    filename: modulePath,
-    loaded: true,
-    exports
-  } as any;
+  defineEsmMockAbs(modulePath, Object.keys(exports), exports);
 }
 
 const { clone } = require('../modules/utils');
@@ -254,7 +252,22 @@ function createBroadcastHarness() {
     }
   });
 
+  // ESM hooks turn mock keys into synthetic named re-exports, so every name
+  // chain_broadcast statically imports must exist here. The error class is a
+  // minimal inline replica of the real one (requiring the real module would
+  // poison the module cache and bypass the mock).
+  class BroadcastUncertainError extends Error {
+    code: string;
+    constructor(message: string) {
+      super(message);
+      this.name = 'BroadcastUncertainError';
+      this.code = 'BROADCAST_UNCERTAIN';
+    }
+  }
+
   registerMock(credentialClientPath, {
+    BroadcastUncertainError,
+    DEFAULT_BROADCAST_TIMEOUT_MS: 30000,
     isCredentialDaemonReady: () => calls.daemonReady,
     broadcastOperationViaCredentialDaemon: async (accountName: any, operation: any, options: any) => {
       calls.daemon.broadcast.push({ accountName, operation, options });
@@ -706,14 +719,21 @@ async function testChainActions() {
   console.log('    PASS');
 }
 
-async function main() {
-  await testChainQueries();
-  await testChainBroadcast();
-  await testChainActions();
-  console.log('claw chain layer tests passed');
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+runEsmMockStages(
+  ['chain-queries', 'chain-broadcast', 'chain-actions'],
+  async (stage: string) => {
+    if (stage === 'chain-queries') {
+      await testChainQueries();
+      return;
+    }
+    if (stage === 'chain-broadcast') {
+      await testChainBroadcast();
+      return;
+    }
+    if (stage === 'chain-actions') {
+      await testChainActions();
+      return;
+    }
+    throw new Error(`Unknown stage: ${stage}`);
+  }
+);

package/claw/tests/test_claw_data_flow.ts

@@ -2,18 +2,16 @@
 
 const assert = require('assert');
 const Module = require('module');
+const { runEsmMockStages, defineEsmMockAbs } = require('../../tests/helpers/esm_mocks');
 
-function clearModule(modulePath: string) {
-  delete require.cache[modulePath];
+// Compiled ESM graphs cannot be mocked via require.cache; the helper installs
+// loader hooks (one child process per stage so fresh module instances load).
+function clearModule(_modulePath: string) {
+  /* no-op under ESM hooks */
 }
 
 function registerMock(modulePath: string, exports: any) {
-  require.cache[modulePath] = {
-    id: modulePath,
-    filename: modulePath,
-    loaded: true,
-    exports
-  } as any;
+  defineEsmMockAbs(modulePath, Object.keys(exports), exports);
 }
 
 const { clone } = require('../modules/utils');
@@ -503,15 +501,25 @@ function testLiquidityPoolsWrapper() {
   console.log('    PASS');
 }
 
-async function main() {
-  await testPositionDiscoveryAndFeedSource();
-  await testDecisionLoop();
-  await testKibanaPriceSource();
-  testLiquidityPoolsWrapper();
-  console.log('claw data flow tests passed');
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+runEsmMockStages(
+  ['discovery-feed', 'decision-loop', 'kibana', 'liquidity-pools'],
+  async (stage: string) => {
+    if (stage === 'discovery-feed') {
+      await testPositionDiscoveryAndFeedSource();
+      return;
+    }
+    if (stage === 'decision-loop') {
+      await testDecisionLoop();
+      return;
+    }
+    if (stage === 'kibana') {
+      await testKibanaPriceSource();
+      return;
+    }
+    if (stage === 'liquidity-pools') {
+      testLiquidityPoolsWrapper();
+      return;
+    }
+    throw new Error(`Unknown stage: ${stage}`);
+  }
+);

package/claw/tests/test_claw_domain_logic.ts

@@ -4,18 +4,16 @@ const assert = require('assert');
 const fs = require('fs/promises');
 const os = require('os');
 const path = require('path');
+const { runEsmMockStages, defineEsmMockAbs } = require('../../tests/helpers/esm_mocks');
 
-function clearModule(modulePath: string) {
-  delete require.cache[modulePath];
+// Compiled ESM graphs cannot be mocked via require.cache; the helper installs
+// loader hooks (one child process per stage so fresh module instances load).
+function clearModule(_modulePath: string) {
+  /* no-op under ESM hooks */
 }
 
 function registerMock(modulePath: string, exports: any) {
-  require.cache[modulePath] = {
-    id: modulePath,
-    filename: modulePath,
-    loaded: true,
-    exports
-  } as any;
+  defineEsmMockAbs(modulePath, Object.keys(exports), exports);
 }
 
 const { clone } = require('../modules/utils');
@@ -98,6 +96,7 @@ function createHonestHarness(options: any = {}) {
       calls.getCallOrders.push({ assetId, limit });
       return [{ id: `${assetId}-call-1` }];
     },
+    getObjects: async () => [],
     listAssets: async (lowerBound: string, limit: any) => {
       calls.listAssets.push({ lowerBound, limit });
       return listAssetPages.shift() || [];
@@ -452,14 +451,21 @@ async function testPositionManager() {
   console.log('    PASS');
 }
 
-async function main() {
-  await testHonestEcosystem();
-  await testHonestEcosystemPaginationAndUnresolvedPair();
-  await testPositionManager();
-  console.log('claw domain logic tests passed');
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+runEsmMockStages(
+  ['honest', 'honest-pagination', 'position-manager'],
+  async (stage: string) => {
+    if (stage === 'honest') {
+      await testHonestEcosystem();
+      return;
+    }
+    if (stage === 'honest-pagination') {
+      await testHonestEcosystemPaginationAndUnresolvedPair();
+      return;
+    }
+    if (stage === 'position-manager') {
+      await testPositionManager();
+      return;
+    }
+    throw new Error(`Unknown stage: ${stage}`);
+  }
+);

package/claw/tests/test_claw_manifest_and_matrix.ts

@@ -1,6 +1,7 @@
 'use strict';
 
 const assert = require('assert');
+const fs = require('fs');
 const path = require('path');
 
 // ---------------------------------------------------------------------------
@@ -154,6 +155,25 @@ function testClawManifest() {
 // dexbot_bridge — getDexbot2Root branching only
 // ---------------------------------------------------------------------------
 
+// Repo root located independently of the compiled layout: compiled tests run
+// from <repo>/dist/claw/tests, so a fixed __dirname offset would point at
+// dist/ instead of the repo. The repo root is the nearest ancestor holding
+// package.json plus both the modules/ and claw/ source trees.
+function findRepoRoot(startDir: string) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (
+      fs.existsSync(path.join(dir, 'package.json')) &&
+      fs.existsSync(path.join(dir, 'modules')) &&
+      fs.existsSync(path.join(dir, 'claw'))
+    ) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error('Unable to locate DEXBot2 repo root');
+}
+
 function testDexbotBridgeRootResolution() {
   const bridgePath = require.resolve('../modules/dexbot_bridge');
   const { Config } = require('../../modules/config');
@@ -173,14 +193,14 @@ function testDexbotBridgeRootResolution() {
   }
 
   // --- Branch 2: no DEXBOT2_ROOT, auto-detected local repo layout ---
-  // The test is already running inside the DEXBot2 repo, so the existsSync
-  // check for modules/order/index.ts should resolve to the repo root.
+  // The test runs inside the DEXBot2 repo, so the existsSync candidate check
+  // (dist/modules/order/index.js) should resolve to the repo root itself.
   delete require.cache[bridgePath];
   Config.DEXBOT2_ROOT = undefined;
   try {
     const bridge = require('../modules/dexbot_bridge');
     const root = bridge.getDexbot2Root();
-    const expectedRoot = path.resolve(__dirname, '..', '..');
+    const expectedRoot = findRepoRoot(__dirname);
     assert.strictEqual(root, expectedRoot);
   } finally {
     Config.DEXBOT2_ROOT = savedRoot;

package/claw/tests/test_claw_mcp_transport.ts

@@ -6,7 +6,6 @@ const os = require('os');
 const { getErrorMessage } = require('../../modules/utils/errors');
 const { spawnSync } = require('child_process');
 const path = require('path');
-const { isDistCodeRoot } = require('../../modules/launcher/runtime_entry');
 const mcpServer = require('../scripts/claw_mcp_server');
 
 function encodeNewlineMessage(message: any) {
@@ -31,7 +30,7 @@ async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.20'
+        version: '1.4.22'
       },
       protocolVersion: '2024-11-05'
     }
@@ -143,10 +142,17 @@ async function testHandleRequestEmitsNewlineJson() {
 }
 
 function runServerProcess(input: any) {
-  const repoRoot = path.resolve(__dirname, '..', '..');
+  // Resolve the real checkout root (works from both the source tree and the
+  // compiled dist/claw/tests location) and prefer the compiled server script.
+  let repoRoot = path.resolve(__dirname, '..', '..');
+  while (!fs.existsSync(path.join(repoRoot, 'package.json'))) {
+    const parent = path.dirname(repoRoot);
+    if (parent === repoRoot) throw new Error('Unable to locate DEXBot2 checkout root');
+    repoRoot = parent;
+  }
   const clawRoot = path.resolve(__dirname, '..');
-  const _isDist = isDistCodeRoot(path.dirname(__dirname));
-  const scriptPath = path.join(clawRoot, 'scripts', 'claw_mcp_server' + (_isDist ? '.js' : '.ts'));
+  const scriptBase = path.join(clawRoot, 'scripts', 'claw_mcp_server');
+  const scriptPath = fs.existsSync(`${scriptBase}.js`) ? `${scriptBase}.js` : `${scriptBase}.ts`;
   const scriptRel = path.relative(repoRoot, scriptPath);
 
   const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'claw-mcp-transport-'));
@@ -155,8 +161,7 @@ function runServerProcess(input: any) {
   fs.writeFileSync(inputPath, input, 'utf8');
 
   try {
-    const loaderArgs = _isDist ? '' : '--import tsx ';
-    const shellCommand = `cat ${shellQuote(inputPath)} | ${shellQuote(process.execPath)} --no-warnings ${loaderArgs}${shellQuote(scriptRel)} --profile-root ${shellQuote(repoRoot)} > ${shellQuote(outputPath)}`;
+    const shellCommand = `cat ${shellQuote(inputPath)} | ${shellQuote(process.execPath)} --no-warnings ${shellQuote(scriptRel)} --profile-root ${shellQuote(repoRoot)} > ${shellQuote(outputPath)}`;
     const run = spawnSync('/bin/sh', ['-lc', shellCommand], {
       cwd: repoRoot,
       encoding: 'utf8'
@@ -182,7 +187,7 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.20'
+        version: '1.4.22'
       },
       protocolVersion: '2024-11-05'
     }