dexbot 1.4.11 → 1.4.13

package/claw/modules/claw_launcher.ts

@@ -0,0 +1,452 @@
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+import { getStorage } from '../../modules/storage/index.js';
+import { path } from '../../modules/path_api.js';
+import { PATHS, getRecalculateTriggerFile } from '../../modules/paths.js';
+import { loadSettingsFile, resolveRawBotEntries, saveSettingsFile, normalizeBotEntries } from '../../modules/bot_settings.js';
+import { normalizeMode, detectMode, setPreferredMode, describeModeChoice } from './launcher_mode_detector.js';
+import { normalizeRoot, resolveRuntimeScript } from './launcher_paths.js';
+import { getErrorMessage } from '../../modules/utils/errors.js';
+'use strict';
+
+const storage = getStorage();
+
+let _chainKeys: any;
+function getChainKeys(): any {
+    if (_chainKeys === undefined) {
+        try {
+            _chainKeys = require('../../modules/chain_keys');
+        } catch {
+            _chainKeys = null;
+        }
+    }
+    if (!_chainKeys) {
+        throw new Error('chain_keys module not available in this environment');
+    }
+    return _chainKeys;
+}
+
+let _spawn: any;
+function getSpawn(): any {
+    if (_spawn === undefined) {
+        try {
+            _spawn = require('child_process').spawn;
+        } catch {
+            _spawn = null;
+        }
+    }
+    if (!_spawn) {
+        throw new Error('child_process.spawn not available in this environment');
+    }
+    return _spawn;
+}
+
+let _pm2: any;
+function getPM2Module(): any {
+    if (_pm2 === undefined) {
+        try {
+            _pm2 = require('../../pm2');
+        } catch {
+            _pm2 = null;
+        }
+    }
+    if (!_pm2) {
+        throw new Error('pm2 module not available in this environment');
+    }
+    return _pm2;
+}
+
+/**
+ * Start a bot directly (background, spawned as detached child process).
+ * Returns immediately with PID and command info.
+ * @param {string|null} botName - Bot name or null for default
+ * @param {Object} [options={}] - Options including profileRoot
+ * @returns {Promise<Object>} { started: true, botName, pid, command }
+ */
+async function launcherStart(botName: string | null, options: Record<string, any> = {}) {
+  const ROOT = normalizeRoot(options);
+  const dexbotPath = resolveRuntimeScript(ROOT, 'dexbot.js');
+
+  const args = ['test'];
+  if (botName) {
+    args.push(botName);
+  }
+
+  const child = getSpawn()('node', [dexbotPath, ...args], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: ROOT
+  });
+
+  child.unref();
+
+  return {
+    started: true,
+    botName: botName || 'default',
+    pid: child.pid,
+    command: botName ? `dexbot test ${botName}` : 'dexbot test',
+  };
+}
+
+/**
+ * Dry-run a bot (no broadcast).
+ * @param {string|null} botName - Bot name or null for default
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { started: true, botName, pid, command, dryRun: true }
+ */
+async function launcherDrystart(botName: string | null, options: Record<string, any> = {}) {
+  const ROOT = normalizeRoot(options);
+  const dexbotPath = resolveRuntimeScript(ROOT, 'dexbot.js');
+
+  const args = ['drystart'];
+  if (botName) {
+    args.push(botName);
+  }
+
+  const child = getSpawn()('node', [dexbotPath, ...args], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: ROOT
+  });
+
+  child.unref();
+
+  return {
+    started: true,
+    botName: botName || 'default',
+    pid: child.pid,
+    command: botName ? `dexbot drystart ${botName}` : 'dexbot drystart',
+    dryRun: true,
+  };
+}
+
+/**
+ * Reset a bot grid (writes trigger file).
+ * @param {string|null} botName - Bot name or null for all active
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { reset: true, targets: [...] }
+ */
+async function launcherReset(botName: string | null, options: Record<string, any> = {}) {
+  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+
+  const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
+  const entries = normalizeBotEntries(resolveRawBotEntries(config));
+
+  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active);
+
+  if (botName && targets.length === 0) {
+    throw new Error(`Bot '${botName}' not found in profiles/bots.json`);
+  }
+
+  const triggered: Array<Record<string, any>> = [];
+
+  for (const bot of targets) {
+    try {
+      const triggerFile = getRecalculateTriggerFile(bot.botKey);
+      storage.writeFile(triggerFile, new Date().toISOString());
+      triggered.push({
+        botName: bot.name,
+        triggerFile: path.basename(triggerFile),
+      });
+    } catch (err: any) {
+      throw new Error(`Failed to write trigger for '${bot.name}': ${getErrorMessage(err)}`);
+    }
+  }
+
+  return {
+    reset: true,
+    targets: triggered,
+  };
+}
+
+/**
+ * Disable a bot in config.
+ * @param {string|null} botName - Bot name or null for all
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { disabled: true, targets: [...] } or { disabled: false, reason: '...' }
+ */
+async function launcherDisable(botName: string | null, options: Record<string, any> = {}) {
+  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+
+  const { config, filePath } = loadSettingsFile(PROFILES_BOTS_FILE);
+  const entries = resolveRawBotEntries(config);
+
+  if (!botName) {
+    // Disable all
+    let updated = false;
+    entries.forEach((entry: any) => {
+      if (entry.active !== false) {
+        entry.active = false;
+        updated = true;
+      }
+    });
+
+    if (!updated) {
+      return { disabled: false, reason: 'No active bots to disable' };
+    }
+
+    saveSettingsFile(config, filePath);
+    return {
+      disabled: true,
+      targets: entries.map((b: any) => ({ botName: b.name, active: false })),
+    };
+  }
+
+  const match = entries.find((b: any) => b.name === botName);
+  if (!match) {
+    throw new Error(`Bot '${botName}' not found in profiles/bots.json`);
+  }
+
+  if (match.active === false) {
+    return { disabled: false, reason: `Bot '${botName}' is already inactive` };
+  }
+
+  match.active = false;
+  saveSettingsFile(config, filePath);
+
+  return {
+    disabled: true,
+    targets: [{ botName: botName, active: false }],
+  };
+}
+
+/**
+ * Start bots via PM2 (production-grade, managed).
+ * Requires credential daemon to already be running.
+ * @param {string|null} botName - Bot name or null for all active
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { started: true, targets: [{ botName, pm2: true }] }
+ */
+async function launcherPm2Start(botName: string | null, options: Record<string, any> = {}) {
+  const ROOT = normalizeRoot(options);
+  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+
+  // Validate bot configuration first (better error message)
+  const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
+  const entries = normalizeBotEntries(resolveRawBotEntries(config));
+
+  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active);
+
+  if (botName && targets.length === 0) {
+    throw new Error(`Bot '${botName}' not found or not active in profiles/bots.json`);
+  }
+
+  // Then check if daemon is ready
+  if (!(await getChainKeys().isDaemonResponsive())) {
+    throw new Error(
+      'Credential daemon is not running. Start it first with: dexbot pm2 claw-only'
+    );
+  }
+
+  // Generate ecosystem config and get apps array
+  getPM2Module().generateEcosystemConfig({ clawOnly: false, exitOnError: false });
+  const apps = getPM2Module().buildEcosystemApps({ clawOnly: false });
+
+  // Filter apps if specific bot requested
+  let appsToStart = apps;
+  if (botName) {
+    appsToStart = apps.filter((app: any) => app.name === botName);
+    if (appsToStart.length === 0) {
+      throw new Error(`No PM2 app found for bot '${botName}'`);
+    }
+  }
+
+  // Start via pm2 without bootstrap (daemon already running)
+  await getPM2Module().startManagedRuntimePM2({ apps: appsToStart });
+
+  return {
+    started: true,
+    targets: targets.map((b: any) => ({ botName: b.name, pm2: true })),
+  };
+}
+
+/**
+ * Stop bot processes via PM2.
+ * @param {string} target - Bot name or 'all'
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { stopped: true, target }
+ */
+async function launcherPm2Stop(target: string, options: Record<string, any> = {}) {
+  await getPM2Module().stopPM2Processes(target || 'all');
+  return {
+    stopped: true,
+    target: target || 'all',
+  };
+}
+
+/**
+ * Delete bot processes from PM2.
+ * @param {string} target - Bot name or 'all'
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { deleted: true, target }
+ */
+async function launcherPm2Delete(target: string, options: Record<string, any> = {}) {
+  await getPM2Module().deletePM2Processes(target || 'all');
+  return {
+    deleted: true,
+    target: target || 'all',
+  };
+}
+
+/**
+ * Restart bot processes via PM2.
+ * @param {string} target - Bot name or 'all'
+ * @param {Object} [options={}] - Options
+ * @returns {Promise<Object>} { restarted: true, target }
+ */
+async function launcherPm2Restart(target: string, options: Record<string, any> = {}) {
+  await getPM2Module().restartPM2Processes(target || 'all');
+  return {
+    restarted: true,
+    target: target || 'all',
+  };
+}
+
+/**
+ * Unified launcher command: auto-detects deployment mode and runs accordingly.
+ *
+ * Flow:
+ *   1. Detect mode (stored preference, or suggest based on bot config)
+ *   2. If user needs to choose, return choices for MCP/CLI to handle
+ *   3. If mode is known, delegate to appropriate implementation
+ *   4. Store choice if user provided deploymentMode override
+ *
+ * @param {string|null} botName - Bot name or null for default/all
+ * @param {Object} [options={}] - Options
+ * @param {string} [options.deploymentMode] - Override mode: dexbot-direct, pm2, unlock, claw-only
+ * @param {boolean} [options.setPreference] - If true, save deploymentMode as preferred
+ * @param {string} [options.profileRoot] - Optional profile root
+ * @returns {Promise<Object>}
+ *   Delegated modes: { started: true, mode?, botName?, pid?, command?, targets?, message?, warning? }
+ *   Mode present in claw-only / unlock; absent in dexbot-direct / pm2.
+ *   No-mode: { needsChoice: true, reason, choices: [{ mode, description }], message }
+ */
+async function launcherRun(botName: string | null, options: Record<string, any> = {}) {
+  const detection = detectMode(options);
+  const deploymentMode = options.deploymentMode ? normalizeMode(options.deploymentMode) : null;
+
+  // User is overriding the mode
+  if (options.deploymentMode) {
+    const validModes = ['dexbot-direct', 'pm2', 'unlock', 'claw-only'];
+    if (deploymentMode === null || !validModes.includes(deploymentMode)) {
+      throw new Error(`Invalid deploymentMode: ${options.deploymentMode}. Must be one of: ${validModes.join(', ')}`);
+    }
+
+    // Note if botName is provided for claw-only mode (will be ignored)
+    const clawOnlyWarning = (deploymentMode === 'claw-only' && botName)
+      ? `botName '${botName}' is ignored in claw-only mode (daemon does not target specific bots)`
+      : null;
+
+    // Save as preference if requested
+    if (options.setPreference) {
+      setPreferredMode(deploymentMode, options);
+    }
+
+    // Delegate to appropriate implementation
+    const result = await (async (): Promise<Record<string, any>> => {
+      switch (deploymentMode) {
+        case 'dexbot-direct':
+          return launcherStart(botName, options);
+        case 'pm2':
+          return launcherPm2Start(botName, options);
+        case 'unlock':
+          return launcherUnlockStart(botName, options);
+        case 'claw-only':
+          return launcherClawOnly(options);
+        default:
+          return {};
+      }
+    })();
+    if (clawOnlyWarning) result.warning = clawOnlyWarning;
+    return result;
+  }
+
+  // Mode is known from stored preference
+  if (detection.mode) {
+    switch (detection.mode) {
+      case 'dexbot-direct':
+        return launcherStart(botName, options);
+      case 'pm2':
+        return launcherPm2Start(botName, options);
+      case 'unlock':
+        return launcherUnlockStart(botName, options);
+      case 'claw-only':
+        return launcherClawOnly(options);
+    }
+  }
+
+  // No mode set and user hasn't chosen — ask them
+  return {
+    needsChoice: true,
+    reason: detection.reason,
+    choices: detection.choices.map((mode: string) => ({
+      mode,
+      description: describeModeChoice(mode)
+    })),
+    message: 'Please choose a deployment mode for launcher-run. Provide it in the next call as deploymentMode parameter and set setPreference:true to save your choice.'
+  };
+}
+
+/**
+ * Start credential daemon only (claw-only mode).
+ * @param {Object} [options={}]
+ * @returns {Promise<Object>}
+ */
+async function launcherClawOnly(options: Record<string, any> = {}) {
+  const ROOT = normalizeRoot(options);
+  const pm2ScriptPath = resolveRuntimeScript(ROOT, 'pm2.js');
+
+  const child = getSpawn()('node', [pm2ScriptPath, 'claw-only'], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: ROOT
+  });
+
+  child.unref();
+
+  return {
+    started: true,
+    mode: 'claw-only',
+    message: 'Credential daemon started in background (PM2 managed)',
+    pid: child.pid,
+    command: 'dexbot pm2 claw-only'
+  };
+}
+
+/**
+ * Start via unlock (single password prompt, no PM2).
+ * @param {string|null} botName - Bot name or null for default
+ * @param {Object} [options={}]
+ * @returns {Promise<Object>}
+ */
+async function launcherUnlockStart(botName: string | null, options: Record<string, any> = {}) {
+  const ROOT = normalizeRoot(options);
+  const unlockPath = resolveRuntimeScript(ROOT, 'unlock.js');
+
+  const args = [];
+  if (botName) {
+    args.push(botName);
+  }
+
+  const child = getSpawn()('node', [unlockPath, ...args], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: ROOT
+  });
+
+  child.unref();
+
+  return {
+    started: true,
+    mode: 'unlock',
+    botName: botName || 'default',
+    pid: child.pid,
+    command: botName ? `dexbot start ${botName}` : 'dexbot start',
+    message: 'Bots started via unlock (single password prompt, no PM2)'
+  };
+}
+
+export { launcherRun, launcherStart, launcherDrystart, launcherReset, launcherDisable, launcherPm2Start, launcherPm2Stop, launcherPm2Delete, launcherPm2Restart, launcherClawOnly, launcherUnlockStart }
+

package/claw/modules/claw_manifest.ts

@@ -0,0 +1,55 @@
+
+import { Config } from '../../modules/config.js';
+import { getSupportedClawRuntime, listSupportedClawRuntimes } from './claw_runtime_matrix.js';
+import { buildClawCommandExamples, getClawToolCatalog, listClawCommandNames } from './claw_catalog.js';
+
+function groupCommandsByRisk(tools: any[]) {
+  return tools.reduce((groups: Record<string, string[]>, tool: any) => {
+    const risk = tool.risk || 'read';
+    if (!groups[risk]) {
+      groups[risk] = [];
+    }
+    groups[risk].push(tool.command);
+    return groups;
+  }, {});
+}
+
+function describeClawBridge(options: Record<string, any> = {}) {
+  const tools = getClawToolCatalog();
+  const focusedRuntime = getSupportedClawRuntime(options.runtimeName || options.runtime);
+
+  return {
+    compatibility: {
+      credentialBoundary: 'AI-Bot and DEXBot2 own signing and credentials',
+      name: focusedRuntime?.displayName || 'Claw',
+      recommendedTransport: focusedRuntime ? focusedRuntime.preferredTransport : 'runtime-specific',
+      runtimes: listSupportedClawRuntimes(),
+      trustModel: focusedRuntime?.trustModel || 'Claw runtimes send intents and read context; AI-Bot handles signing through DEXBot2',
+      version: 2, // Incremented for credential-boundary redesign; v1 returned static surfaces only
+    },
+    commandExamples: buildClawCommandExamples(options.scriptPath),
+    commands: listClawCommandNames(),
+    options: {
+      accountName: options.accountName || null,
+      profileRoot: options.profileRoot || Config.DEXBOT_PROFILE_ROOT || null,
+      runtimeName: focusedRuntime ? focusedRuntime.runtime : null,
+      socketPath: options.socketPath || null
+    },
+    surfaces: {
+      credentialClient: 'internal only',
+      honest: 'read-only context + pair pricing',
+      market: 'read-only snapshots',
+      memory: 'memU proactive memory bridge',
+      order: 'DEXBot2 order utilities',
+      profiles: 'DEXBot2 profile-folder adapter, including bot settings read/preview/apply and read-only general.settings.json context',
+      stateStore: 'filesystem-backed AI-Bot state'
+    },
+    tools: {
+      byRisk: groupCommandsByRisk(tools),
+      catalog: tools
+    }
+  };
+}
+
+export { describeClawBridge }
+

package/claw/modules/claw_runtime_matrix.ts

@@ -0,0 +1,104 @@
+const SUPPORTED_CLAW_RUNTIMES = Object.freeze([
+  {
+    runtime: 'openclaw',
+    displayName: 'OpenClaw',
+    nativeIntegration: 'plugin',
+    preferredTransport: 'plugin-or-mcp',
+    skillFile: 'SKILL.md',
+    notes: 'Native plugin registration is preferred; SKILL.md remains the native workflow layer.',
+    trustModel: 'OpenClaw sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'hermes',
+    displayName: 'Hermes',
+    nativeIntegration: 'mcp-plus-skill-md',
+    preferredTransport: 'mcp-stdio-jsonl',
+    skillFile: 'SKILL.md',
+    notes: 'Hermes prefers the shared MCP server via ~/.hermes/config.yaml, with an optional SKILL.md in ~/.hermes/skills for workflow guidance.',
+    trustModel: 'Hermes consumes Claw through the shared MCP server and optional skill guidance; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'openfang',
+    displayName: 'OpenFang',
+    nativeIntegration: 'skill-md',
+    preferredTransport: 'local-cli-json',
+    skillFile: 'SKILL.md',
+    notes: 'OpenFang can load prompt-only SKILL.md skills and shell out to the shared CLI bridge from a local workspace skill.',
+    trustModel: 'OpenFang sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'nanobot',
+    displayName: 'NanoBot',
+    nativeIntegration: 'mcp',
+    preferredTransport: 'mcp-stdio-jsonl',
+    skillFile: 'SKILL.md',
+    notes: 'Native external tool surface is MCP over stdio with newline-delimited JSON-RPC, with SKILL.md used for workflow guidance.',
+    trustModel: 'NanoBot sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'picoclaw',
+    displayName: 'PicoClaw',
+    nativeIntegration: 'mcp',
+    preferredTransport: 'mcp-stdio-jsonl',
+    skillFile: 'SKILL.md',
+    notes: 'PicoClaw mirrors NanoBot on native SKILL.md loading and MCP stdio integration with newline-delimited JSON-RPC.',
+    trustModel: 'PicoClaw sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'nanoclaw',
+    displayName: 'NanoClaw',
+    nativeIntegration: 'skill-md',
+    preferredTransport: 'local-cli-json',
+    skillFile: 'SKILL.md',
+    notes: 'NanoClaw uses Claude Code skill files with a local JSON CLI bridge and workspace-level skill loading.',
+    trustModel: 'NanoClaw sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'zeroclaw',
+    displayName: 'ZeroClaw',
+    nativeIntegration: 'skill-manifest',
+    preferredTransport: 'local-cli-json',
+    skillFile: 'SKILL.toml',
+    notes: 'Native shell-tool manifests with prompts and tool declarations.',
+    trustModel: 'ZeroClaw sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'nullclaw',
+    displayName: 'NullClaw',
+    nativeIntegration: 'skill-manifest',
+    preferredTransport: 'skill-toml-or-mcp',
+    skillFile: 'SKILL.toml',
+    notes: 'NullClaw prefers SKILL.toml in ~/.nullclaw/workspace/skills and can also load Claw through mcp_servers.',
+    trustModel: 'NullClaw sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  },
+  {
+    runtime: 'memu',
+    displayName: 'memU',
+    nativeIntegration: 'subprocess-bridge',
+    preferredTransport: 'local-cli-json-or-mcp',
+    skillFile: 'SKILL.md',
+    notes: 'memU provides 24/7 proactive memory for AI agents. Uses Python subprocess bridge with MCP stdio support for memory operations.',
+    trustModel: 'memU sends intents and reads context; AI-Bot handles signing through DEXBot2'
+  }
+]);
+
+function cloneRuntime(runtime: any) {
+  return { ...runtime };
+}
+
+function listSupportedClawRuntimes() {
+  return SUPPORTED_CLAW_RUNTIMES.map(cloneRuntime);
+}
+
+function getSupportedClawRuntime(runtimeName: string) {
+  if (!runtimeName) {
+    return null;
+  }
+
+  const normalized = String(runtimeName).trim().toLowerCase();
+  const match = SUPPORTED_CLAW_RUNTIMES.find((runtime) => runtime.runtime === normalized);
+  return match ? cloneRuntime(match) : null;
+}
+
+export { getSupportedClawRuntime, listSupportedClawRuntimes }
+