@thirdfy/agent-cli 0.1.46 → 0.2.1

package/src/runtime/handlers.mjs

@@ -0,0 +1,181 @@
+import { negotiateCapabilities } from '../core/http.mjs';
+import { createPolymarketCommands } from '../commands/polymarket.mjs';
+import { createHyperliquidHelpers } from '../commands/hyperliquid.mjs';
+import { createExecuteCommands } from '../commands/execute.mjs';
+import { createWalletCommands } from '../commands/wallet.mjs';
+import { createDelegationCommands } from '../commands/delegation.mjs';
+import { createBootstrapCommands } from '../commands/bootstrap.mjs';
+import { createDiscoveryCommands } from '../commands/discovery.mjs';
+import { createTelemetryCommands } from '../commands/telemetry.mjs';
+import { createCredentialsCommands } from '../commands/credentials.mjs';
+import { createAgentCommands } from '../commands/agent.mjs';
+import { createDoctorCommands } from '../commands/doctor.mjs';
+import { createPromptCommands } from '../commands/prompt.mjs';
+
+/**
+ * Wire command-module factories and local handlers for Commander manifest registration.
+ */
+export function createRuntimeHandlers(deps) {
+  const {
+    printEnvelope,
+    negotiateCapabilitiesForCli,
+    extractAgentApiKey,
+    extractAgentKey,
+    maskSecret,
+    getAuthToken,
+    buildOwnerAuthHeaders,
+    probeBitfinexPermissions,
+    applyActionFilters,
+    getTradingProviderHint,
+    resolveChainSupport,
+    resolveAgentApiKey,
+    getPreparedParams,
+    resolveActionSelection,
+    prepareActionParamsForFlags,
+    enforceOffchainVenueLaneCompatibility,
+    enforceChainCompatibility,
+    executeManagedWalletRun,
+    executeSelfRun,
+    submitSignedTx,
+    runPreflightByMode,
+    runExecutionByMode,
+    applyExecutionFallbackHints,
+    performSelfBroadcast,
+    resolveManagedExecutionPreflight,
+    resolveEffectiveUserDid,
+  } = deps;
+
+  const __discovery = createDiscoveryCommands({
+    printEnvelope,
+    applyActionFilters,
+    getTradingProviderHint,
+    resolveChainSupport,
+    getAuthToken,
+    resolveAgentApiKey,
+  });
+
+  const __telemetry = createTelemetryCommands({
+    printEnvelope,
+    resolveAgentApiKey,
+  });
+
+  const __credentials = createCredentialsCommands({
+    printEnvelope,
+    getAuthToken,
+    buildOwnerAuthHeaders,
+    probeBitfinexPermissions,
+  });
+
+  const __agent = createAgentCommands({
+    printEnvelope,
+    extractAgentApiKey,
+    extractAgentKey,
+    buildOwnerAuthHeaders,
+  });
+
+  const __doctor = createDoctorCommands({
+    printEnvelope,
+    extractAgentApiKey,
+    extractAgentKey,
+    maskSecret,
+    resolveAgentApiKey,
+    buildOwnerAuthHeaders,
+    resolveEffectiveUserDid,
+    loadEthers: deps.loadEthers,
+    resolveOwsBinary: deps.resolveOwsBinary,
+  });
+
+  const __prompt = createPromptCommands({ printEnvelope });
+
+  const __hyperliquid = createHyperliquidHelpers({
+    getPreparedParams,
+    resolveManagedExecutionPreflight,
+  });
+  const { applyHyperliquidAgentWalletAddressDefault } = __hyperliquid;
+
+  const __wallet = createWalletCommands({
+    resolveActionSelection,
+    prepareActionParamsForFlags,
+    enforceOffchainVenueLaneCompatibility,
+    enforceChainCompatibility,
+    applyHyperliquidAgentWalletAddressDefault,
+    executeManagedWalletRun,
+    executeSelfRun,
+    submitSignedTx,
+    printEnvelope,
+  });
+
+  const __execute = createExecuteCommands({
+    resolveActionSelection,
+    prepareActionParamsForFlags,
+    enforceOffchainVenueLaneCompatibility,
+    enforceChainCompatibility,
+    applyHyperliquidAgentWalletAddressDefault,
+    runPreflightByMode,
+    runExecutionByMode,
+    applyExecutionFallbackHints,
+    performSelfBroadcast,
+    executeManagedWalletRun,
+    executeSelfRun,
+    printEnvelope,
+    commandWalletSign: __wallet.commandWalletSign,
+    commandWalletExecute: __wallet.commandWalletExecute,
+  });
+
+  const __delegation = createDelegationCommands({
+    buildOwnerAuthHeaders,
+    printEnvelope,
+    commandRun: __execute.commandRun,
+  });
+
+  const __polymarket = createPolymarketCommands({
+    commandPreflight: __execute.commandPreflight,
+    printEnvelope,
+  });
+
+  const __bootstrap = createBootstrapCommands({
+    printEnvelope,
+    extractAgentApiKey,
+    extractAgentKey,
+    buildOnboardingHelp: __doctor.buildOnboardingHelp,
+    buildWalletChallengePayload: __agent.buildWalletChallengePayload,
+    issueBootstrapToken: __agent.issueBootstrapToken,
+    verifyOwnerWalletChallenge: __agent.verifyOwnerWalletChallenge,
+    resolveEffectiveUserDid,
+    negotiateCapabilities,
+    commandAgentRegister: __agent.commandAgentRegister,
+  });
+
+  return {
+    ...__execute,
+    ...__wallet,
+    ...__delegation,
+    ...__polymarket,
+    ...__bootstrap,
+    ...__discovery,
+    ...__telemetry,
+    ...__credentials,
+    ...__agent,
+    ...__doctor,
+    ...__prompt,
+    commandDoctorSelf: __doctor.commandDoctorSelf,
+    commandDoctorAuth: __doctor.commandDoctorAuth,
+    commandManagedSetup: __doctor.commandManagedSetup,
+    commandCatalogsList: __discovery.commandCatalogsList,
+    commandActions: __discovery.commandActions,
+    commandCreditsBalance: __discovery.commandCreditsBalance,
+    commandDataSummary: __telemetry.commandDataSummary,
+    commandTrackList: __telemetry.commandTrackList,
+    commandTrackAction: __telemetry.commandTrackAction,
+    commandCredentialsUpsert: __credentials.commandCredentialsUpsert,
+    commandCredentialsStatus: __credentials.commandCredentialsStatus,
+    commandAgentRegister: __agent.commandAgentRegister,
+    commandAgentKeyRotate: __agent.commandAgentKeyRotate,
+    commandAgentKeyRevoke: __agent.commandAgentKeyRevoke,
+    commandAgentAuthChallenge: __agent.commandAgentAuthChallenge,
+    commandAgentAuthVerify: __agent.commandAgentAuthVerify,
+    commandAnalyticsPortfolio: __telemetry.commandAnalyticsPortfolio,
+    commandAnalyticsLeaderboard: __telemetry.commandAnalyticsLeaderboard,
+    commandPrompt: __prompt.commandPrompt,
+  };
+}

package/src/runtime/index.mjs

@@ -0,0 +1,4 @@
+export { createThirdfyAgentRuntime } from './main.mjs';
+export { createProviderHints } from './providerHints.mjs';
+export { createRuntimeHandlers } from './handlers.mjs';
+export { createInitialRuntimeContext, applyFlagsToRuntimeContext } from './context.mjs';

package/src/runtime/main.mjs

@@ -0,0 +1,204 @@
+import { createRequire } from 'module';
+import { printEnvelope as corePrintEnvelope } from '../core/envelope.mjs';
+import { negotiateCapabilities } from '../core/http.mjs';
+import {
+  buildCliProgram,
+  collectRootFlags,
+  handleRootOnlyFlows,
+  collectVersionFlagsFromArgv,
+} from '../cli/program.mjs';
+import { createInitialRuntimeContext, applyFlagsToRuntimeContext } from './context.mjs';
+import { createProviderHints } from './providerHints.mjs';
+import { createRuntimeHandlers } from './handlers.mjs';
+import { isCommanderCliError } from './errors.mjs';
+import { createOnboardingHints } from './onboardingHints.mjs';
+import { createAgentExtract } from './agentExtract.mjs';
+import { createAuthHelpers } from './authHelpers.mjs';
+import { createExecutionAmounts } from './execution/amounts.mjs';
+import { createExecutionLanes } from './execution/lanes.mjs';
+import { createExecutionPayloads } from './execution/payloads.mjs';
+import { createExecutionRunners } from './execution/runners.mjs';
+import { createActionSelection } from './actions/selection.mjs';
+import { createBitfinexProbe } from './bitfinexProbe.mjs';
+import { createOwsSigning } from './owsSigning.mjs';
+
+const require = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require('../../package.json');
+
+export function createThirdfyAgentRuntime() {
+  const context = createInitialRuntimeContext();
+  let cliProgram = null;
+
+  function printEnvelope(payload, options = {}) {
+    const jsonMode = Boolean(
+      options.jsonMode ||
+        context.jsonMode ||
+        process.argv.includes('--json') ||
+        (cliProgram ? cliProgram.opts()?.json : false)
+    );
+    corePrintEnvelope(payload, { jsonMode });
+  }
+
+  function prepareContextFromFlags(flags) {
+    return applyFlagsToRuntimeContext(context, flags);
+  }
+
+  async function negotiateCapabilitiesForCli(ctx) {
+    if (ctx.negotiatedCapabilitiesCache) return ctx.negotiatedCapabilitiesCache;
+    const capabilities = await negotiateCapabilities(ctx);
+    ctx.negotiatedCapabilitiesCache = capabilities;
+    return capabilities;
+  }
+
+  const providerHints = createProviderHints({
+    getNegotiatedCapabilitiesCache: () => context.negotiatedCapabilitiesCache,
+  });
+  const { getTradingProviderHint, formatProviderAmbiguousActionHint, formatProviderUnknownActionHint } =
+    providerHints;
+
+  const { extractAgentApiKey, extractAgentKey, maskSecret } = createAgentExtract();
+  const onboarding = createOnboardingHints();
+  const amounts = createExecutionAmounts();
+  const lanes = createExecutionLanes();
+  const auth = createAuthHelpers();
+  const payloads = createExecutionPayloads({
+    getPreparedParams: amounts.getPreparedParams,
+    rawUnitsToDecimalString: amounts.rawUnitsToDecimalString,
+  });
+  const actions = createActionSelection({
+    getTradingProviderHint,
+    formatProviderAmbiguousActionHint,
+    formatProviderUnknownActionHint,
+  });
+  const ows = createOwsSigning();
+  const bitfinex = createBitfinexProbe();
+  const runners = createExecutionRunners({
+    buildIntentPayload: payloads.buildIntentPayload,
+    buildBuildTxPayload: payloads.buildBuildTxPayload,
+    buildManagedExecutePayload: payloads.buildManagedExecutePayload,
+    getPreparedParams: amounts.getPreparedParams,
+    resolveEffectiveUserDid: payloads.resolveEffectiveUserDid,
+    resolveTokenInForFunding: payloads.resolveTokenInForFunding,
+    shouldUseBuildTxPreflight: lanes.shouldUseBuildTxPreflight,
+    shouldUseBuildTxExecution: lanes.shouldUseBuildTxExecution,
+    buildBitfinexOnboardingCommand: onboarding.buildBitfinexOnboardingCommand,
+    inferBitfinexPermissionProfileFromAction: onboarding.inferBitfinexPermissionProfileFromAction,
+    resolveAgentApiKey: payloads.resolveAgentApiKey,
+    loadEthers: ows.loadEthers,
+    signAndBroadcastWithOws: ows.signAndBroadcastWithOws,
+    readEffectBalances: ows.readEffectBalances,
+    resolveUnsignedTx: auth.resolveUnsignedTx,
+    sleepMs: auth.sleepMs,
+  });
+
+  const cliHandlers = createRuntimeHandlers({
+    printEnvelope,
+    negotiateCapabilitiesForCli,
+    extractAgentApiKey,
+    extractAgentKey,
+    maskSecret,
+    getAuthToken: auth.getAuthToken,
+    buildOwnerAuthHeaders: auth.buildOwnerAuthHeaders,
+    probeBitfinexPermissions: bitfinex.probeBitfinexPermissions,
+    applyActionFilters: actions.applyActionFilters,
+    getTradingProviderHint,
+    resolveChainSupport: lanes.resolveChainSupport,
+    resolveAgentApiKey: payloads.resolveAgentApiKey,
+    getPreparedParams: amounts.getPreparedParams,
+    resolveActionSelection: actions.resolveActionSelection,
+    prepareActionParamsForFlags: amounts.prepareActionParamsForFlags,
+    enforceOffchainVenueLaneCompatibility: lanes.enforceOffchainVenueLaneCompatibility,
+    enforceChainCompatibility: lanes.enforceChainCompatibility,
+    executeManagedWalletRun: runners.executeManagedWalletRun,
+    executeSelfRun: runners.executeSelfRun,
+    submitSignedTx: runners.submitSignedTx,
+    runPreflightByMode: runners.runPreflightByMode,
+    runExecutionByMode: runners.runExecutionByMode,
+    applyExecutionFallbackHints: runners.applyExecutionFallbackHints,
+    performSelfBroadcast: runners.performSelfBroadcast,
+    resolveManagedExecutionPreflight: runners.resolveManagedExecutionPreflight,
+    resolveEffectiveUserDid: payloads.resolveEffectiveUserDid,
+    loadEthers: ows.loadEthers,
+    resolveOwsBinary: ows.resolveOwsBinary,
+  });
+
+  cliProgram = buildCliProgram({
+    CLI_VERSION,
+    handlers: cliHandlers,
+    getContext: () => context,
+    getJsonMode: () => context.jsonMode,
+    printEnvelope,
+    prepareContextFromFlags,
+    negotiateCapabilities: negotiateCapabilitiesForCli,
+  });
+
+  async function runMain() {
+    const rootFlowDeps = {
+      collectRootFlags,
+      prepareContextFromFlags,
+      printEnvelope,
+      CLI_VERSION,
+      getApiBase: () => context.apiBase,
+    };
+
+    const earlyVersionFlags = collectVersionFlagsFromArgv(process.argv);
+    if (earlyVersionFlags.version) {
+      prepareContextFromFlags(earlyVersionFlags);
+      await handleRootOnlyFlows(cliProgram, rootFlowDeps, earlyVersionFlags);
+      return;
+    }
+
+    try {
+      await cliProgram.parseAsync(process.argv, { from: 'node' });
+      const versionHandled = await handleRootOnlyFlows(cliProgram, rootFlowDeps);
+      if (versionHandled) return;
+    } catch (error) {
+      if (isCommanderCliError(error)) {
+        const flags = collectRootFlags(cliProgram);
+        if (
+          flags.version &&
+          (error.code === 'commander.help' || error.code === 'commander.helpDisplayed')
+        ) {
+          prepareContextFromFlags(flags);
+          await handleRootOnlyFlows(cliProgram, rootFlowDeps);
+          return;
+        }
+        if (error.code === 'commander.help' || error.code === 'commander.helpDisplayed') {
+          return;
+        }
+        const exitCode = Number(error.exitCode ?? 1);
+        process.exit(exitCode);
+      }
+      throw error;
+    }
+  }
+
+  function handleCliEntryError(error) {
+    const statusCode = Number(error?.statusCode || 0) || undefined;
+    const payload = error?.payload && typeof error.payload === 'object' ? error.payload : {};
+    const blockedReason = String(payload.blockedReason || payload.error || '').trim() || undefined;
+    const blockedStage = String(payload.blockedStage || '').trim() || undefined;
+    const onboardingHint = onboarding.buildTopLevelOnboardingHint(payload);
+    printEnvelope({
+      success: false,
+      code: statusCode ? 'API_REQUEST_FAILED' : 'CLI_UNHANDLED_ERROR',
+      message: error?.message || 'Unhandled CLI error',
+      data: {
+        statusCode,
+        blockedReason,
+        blockedStage,
+        onboardingHint,
+        payload,
+      },
+      meta: { version: CLI_VERSION, apiBase: context.apiBase },
+    });
+    process.exit(1);
+  }
+
+  return {
+    runMain,
+    handleCliEntryError,
+    getContext: () => context,
+    getCliProgram: () => cliProgram,
+  };
+}

package/src/runtime/onboardingHints.mjs

@@ -0,0 +1,54 @@
+import { BITFINEX_PERMISSION_PROFILES } from '../core/constants.mjs';
+export function createOnboardingHints() {
+function buildBitfinexOnboardingCommand(permissionProfile = 'funding') {
+  const profile = BITFINEX_PERMISSION_PROFILES[permissionProfile] || BITFINEX_PERMISSION_PROFILES.funding;
+  return [
+    'thirdfy-agent credentials upsert',
+    '--auth-token "$THIRDFY_AUTH_TOKEN"',
+    '--venue bitfinex',
+    `--permission-profile ${profile.id}`,
+    `--credential-ref ${profile.credentialRef}`,
+    '--api-key "<BITFINEX_API_KEY>"',
+    '--api-secret "<BITFINEX_API_SECRET>"',
+    '--verify-permissions',
+    '--json',
+  ].join(' ');
+}
+
+function inferBitfinexPermissionProfileFromAction(actionName) {
+  const action = String(actionName || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[_\s]+/g, '-');
+  if (!action.includes('bitfinex')) return 'funding';
+  return action.includes('bitfinex-order') ? 'spot' : 'funding';
+}
+
+function buildTopLevelOnboardingHint(payload) {
+  const reason = String(payload?.blockedReason || payload?.error || '').trim();
+  const permissionProfile = inferBitfinexPermissionProfileFromAction(
+    payload?.resolvedAction || payload?.action || payload?.requestedAction
+  );
+  if (!reason) return null;
+  if (
+    [
+      'CEX_CREDENTIAL_NOT_FOUND',
+      'BITFINEX_CREDENTIALS_NOT_IN_CONTEXT',
+      'BITFINEX_CREDENTIALS_NOT_IN_THIRDFY_DELEGATION_CONTEXT',
+      'BITFINEX_ENV_CREDENTIALS_NOT_CONFIGURED',
+    ].includes(reason)
+  ) {
+    return {
+      type: 'bitfinex_credentials',
+      command: buildBitfinexOnboardingCommand(permissionProfile),
+    };
+  }
+  return null;
+}
+
+  return {
+    buildBitfinexOnboardingCommand,
+    inferBitfinexPermissionProfileFromAction,
+    buildTopLevelOnboardingHint,
+  };
+}

package/src/runtime/owsSigning.mjs

@@ -0,0 +1,118 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { createCliError } from '../core/envelope.mjs';
+export function createOwsSigning() {
+async function loadEthers() {
+  const candidates = ['ethers', path.join(process.cwd(), 'node_modules', 'ethers')];
+  for (const candidate of candidates) {
+    try {
+      return require(candidate);
+    } catch {
+      // continue
+    }
+  }
+  throw new Error('Could not load ethers dependency for self-exec');
+}
+
+function resolveOwsBinary() {
+  const explicit = String(process.env.OWS_CLI_PATH || '').trim();
+  if (explicit && fs.existsSync(explicit)) return explicit;
+  const localBin = path.join(process.cwd(), 'node_modules', '.bin', 'ows');
+  if (fs.existsSync(localBin)) return localBin;
+  const which = spawnSync('which', ['ows'], { encoding: 'utf-8' });
+  const discovered = String(which.stdout || '').trim();
+  if (discovered) return discovered;
+  throw new Error('ows CLI not found. Install it or set OWS_CLI_PATH.');
+}
+
+function signUnsignedTxWithOws(unsignedHex, walletName, chainId) {
+  const passphrase = String(process.env.OWS_PASSPHRASE || process.env.OWS_API_KEY || '').trim();
+  if (!passphrase) {
+    throw new Error('Set OWS_PASSPHRASE (or OWS_API_KEY) for self-exec signing.');
+  }
+  const ows = resolveOwsBinary();
+  const txHex = String(unsignedHex).startsWith('0x') ? String(unsignedHex).slice(2) : String(unsignedHex);
+  const res = spawnSync(
+    ows,
+    ['sign', 'tx', '--wallet', walletName, '--chain', `eip155:${chainId}`, '--tx', txHex, '--json'],
+    { env: { ...process.env, OWS_PASSPHRASE: passphrase }, encoding: 'utf-8' }
+  );
+  const out = String(res.stdout || '').trim();
+  if (res.status !== 0 || !out) {
+    throw new Error(`ows sign tx failed: ${String(res.stderr || out || res.status).slice(0, 300)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(out);
+  } catch {
+    throw new Error(`ows sign tx returned non-json payload: ${out.slice(0, 200)}`);
+  }
+  const signature = String(parsed.signature || '').replace(/^0x/i, '');
+  if (signature.length < 128) {
+    throw new Error('Invalid OWS signature payload');
+  }
+  return {
+    recoveryId: Number(parsed.recovery_id),
+    r: `0x${signature.slice(0, 64)}`,
+    s: `0x${signature.slice(64, 128)}`,
+  };
+}
+
+async function signAndBroadcastWithOws({ txd, chainId, walletAddress, owsWalletName, rpcUrl }) {
+  const ethers = await loadEthers();
+  const { JsonRpcProvider, Transaction, Signature } = ethers;
+  const provider = new JsonRpcProvider(rpcUrl, chainId);
+  const nonce = await provider.getTransactionCount(walletAddress, 'pending');
+  const fee = await provider.getFeeData();
+  const txFields = {
+    type: 2,
+    chainId,
+    nonce,
+    to: String(txd.to).toLowerCase(),
+    data: txd.data,
+    value: txd.value ? BigInt(txd.value) : 0n,
+    gasLimit: txd.gas ? BigInt(txd.gas) : txd.gasLimit ? BigInt(txd.gasLimit) : 500000n,
+    maxFeePerGas: fee.maxFeePerGas ?? fee.gasPrice ?? 2_000_000_000n,
+    maxPriorityFeePerGas: fee.maxPriorityFeePerGas ?? 1_000_000_000n,
+  };
+  const unsigned = Transaction.from(txFields);
+  const sigParts = signUnsignedTxWithOws(unsigned.unsignedSerialized, owsWalletName, chainId);
+  const sig = Signature.from({ r: sigParts.r, s: sigParts.s, yParity: sigParts.recoveryId });
+  const tx = Transaction.from(unsigned.unsignedSerialized);
+  tx.signature = sig;
+  const sent = await provider.broadcastTransaction(tx.serialized);
+  return { sent };
+}
+
+async function readTokenBalanceRaw(rpcUrl, walletAddress, tokenAddress) {
+  const ethers = await loadEthers();
+  const { JsonRpcProvider, Interface } = ethers;
+  const provider = new JsonRpcProvider(rpcUrl);
+  const erc20 = new Interface(['function balanceOf(address owner) view returns (uint256)']);
+  const response = await provider.call({
+    to: tokenAddress,
+    data: erc20.encodeFunctionData('balanceOf', [walletAddress]),
+  });
+  const decoded = erc20.decodeFunctionResult('balanceOf', response);
+  return BigInt(decoded[0].toString()).toString();
+}
+
+async function readEffectBalances(rpcUrl, walletAddress, tokenIn, tokenOut) {
+  const [inBal, outBal] = await Promise.all([
+    readTokenBalanceRaw(rpcUrl, walletAddress, tokenIn),
+    readTokenBalanceRaw(rpcUrl, walletAddress, tokenOut),
+  ]);
+  return { tokenIn: inBal, tokenOut: outBal };
+}
+
+  return {
+    loadEthers,
+    resolveOwsBinary,
+    signUnsignedTxWithOws,
+    signAndBroadcastWithOws,
+    readTokenBalanceRaw,
+    readEffectBalances,
+  };
+}