@exagent/agent 0.3.2 → 0.3.4

package/src/runtime.ts

@@ -58,6 +58,21 @@ try { SDK_VERSION = _require('../package.json').version; } catch {}
 /** Number of consecutive cycle failures before switching to idle */
 const MAX_CONSECUTIVE_FAILURES = 3;
 
+function getCycleErrorHint(category: string, msg: string): string | null {
+  const lower = msg.toLowerCase();
+  if (category === 'auth' || lower.includes('401') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('authentication'))
+    return 'Check your LLM API key — update via npx exagent setup';
+  if (category === 'network' || lower.includes('econnrefused') || lower.includes('enotfound') || lower.includes('fetch failed') || lower.includes('timeout'))
+    return 'Network connectivity issue — check your internet connection';
+  if (category === 'venue' || lower.includes('hyperliquid') || lower.includes('polymarket') || lower.includes('venue'))
+    return 'Venue API error — the venue may be experiencing issues';
+  if (category === 'strategy' || lower.includes('invalid') && lower.includes('signal') || lower.includes('strategy'))
+    return 'Strategy returned invalid output — check your strategy file';
+  if (lower.includes('rate limit') || lower.includes('429'))
+    return 'Rate limited — consider increasing tradingIntervalMs';
+  return null;
+}
+
 export class AgentRuntime {
   private config: RuntimeConfig;
   private relay: RelayClient;
@@ -809,12 +824,13 @@ export class AgentRuntime {
       timings.totalMs = Date.now() - cycleStart;
 
       const categorized = this.diagnostics.recordError(err as Error);
-      log.error('cycle', `Cycle error: ${errMsg}`, {
+      const hint = getCycleErrorHint(categorized.category, errMsg);
+      log.error('cycle', `Cycle error: ${errMsg}${hint ? ` — ${hint}` : ''}`, {
         cycle: this.cycleCount,
         totalMs: timings.totalMs,
         category: categorized.category,
       });
-      this.signal.reportError('Cycle Error', errMsg);
+      this.signal.reportError('Cycle Error', `${errMsg}${hint ? ` — ${hint}` : ''}`);
 
       this.diagnostics.recordCycle({
         cycleNumber: this.cycleCount,

package/src/setup.ts

@@ -33,6 +33,24 @@ function cancelled(): never {
   process.exit(0);
 }
 
+function isNonInteractive(): boolean {
+  return process.env.EXAGENT_NONINTERACTIVE === '1' || process.env.EXAGENT_NONINTERACTIVE === 'true';
+}
+
+const LLM_KEY_PREFIXES: Record<string, string> = {
+  openai: 'sk-',
+  anthropic: 'sk-ant-',
+};
+
+function validateLlmKeyFormat(provider: string, key: string): string | undefined {
+  if (!key.trim()) return 'API key is required.';
+  const expectedPrefix = LLM_KEY_PREFIXES[provider];
+  if (expectedPrefix && !key.startsWith(expectedPrefix)) {
+    return `${provider} API keys typically start with "${expectedPrefix}". Double-check your key.`;
+  }
+  if (key.length < 10) return 'API key seems too short.';
+}
+
 // ---------------------------------------------------------------------------
 // Step 1: Bootstrap
 // ---------------------------------------------------------------------------
@@ -74,6 +92,24 @@ async function setupWallet(config: RuntimeConfigFile): Promise<string> {
     return config.wallet.privateKey;
   }
 
+  // Non-interactive: env var wallet
+  if (isNonInteractive()) {
+    const mode = process.env.EXAGENT_WALLET_MODE || 'generate';
+    if (mode === 'import') {
+      const key = process.env.EXAGENT_WALLET_KEY;
+      if (!key || !/^0x[a-fA-F0-9]{64}$/.test(key)) {
+        throw new Error('EXAGENT_WALLET_KEY must be a valid 0x-prefixed 64-char hex private key in non-interactive mode');
+      }
+      const address = privateKeyToAccount(key as `0x${string}`).address;
+      printDone(`Wallet imported: ${pc.dim(address)}`);
+      return key;
+    }
+    const privateKey = generatePrivateKey();
+    const address = privateKeyToAccount(privateKey).address;
+    printDone(`Wallet created: ${pc.dim(address)}`);
+    return privateKey;
+  }
+
   const method = await clack.select({
     message: 'How would you like to set up your wallet?',
     options: [
@@ -114,62 +150,52 @@ const LLM_PROVIDERS = ['openai', 'anthropic', 'google', 'deepseek', 'mistral', '
 
 async function setupLlm(
   config: RuntimeConfigFile,
-  bootstrapPayload: BootstrapPayload,
 ): Promise<{ provider: string; model: string; apiKey: string }> {
-  // Provider
-  let provider = config.llm?.provider || bootstrapPayload.llm?.provider;
-  if (provider) {
-    printInfo(`Provider: ${pc.cyan(provider)} ${pc.dim('(from dashboard)')}`);
-  } else {
-    const selected = await clack.select({
-      message: 'LLM provider:',
-      options: LLM_PROVIDERS.map(p => ({ value: p, label: p })),
-    });
-    if (clack.isCancel(selected)) cancelled();
-    provider = selected;
+  // LLM config is always entered locally — never pulled from bootstrap.
+  // Config file may have provider/model as defaults from the deploy wizard.
+
+  // Non-interactive mode
+  if (isNonInteractive()) {
+    const provider = process.env.EXAGENT_LLM_PROVIDER || config.llm?.provider;
+    const model = process.env.EXAGENT_LLM_MODEL || config.llm?.model;
+    const apiKey = process.env.EXAGENT_LLM_KEY;
+    if (!provider) throw new Error('EXAGENT_LLM_PROVIDER required in non-interactive mode');
+    if (!model) throw new Error('EXAGENT_LLM_MODEL required in non-interactive mode');
+    if (!apiKey) throw new Error('EXAGENT_LLM_KEY required in non-interactive mode');
+    printDone('LLM configured');
+    return { provider, model, apiKey };
   }
 
-  // Model
-  let model = config.llm?.model || bootstrapPayload.llm?.model;
-  if (model) {
-    printInfo(`Model: ${pc.cyan(model)} ${pc.dim('(from dashboard)')}`);
-  } else {
-    const entered = await clack.text({
-      message: 'LLM model:',
-      placeholder: 'gpt-4o',
-      validate: (val) => {
-        if (!val.trim()) return 'Model name is required.';
-      },
-    });
-    if (clack.isCancel(entered)) cancelled();
-    model = entered;
-  }
+  // Provider — use config as default selection if available
+  const defaultProvider = config.llm?.provider;
+  const providerOptions = LLM_PROVIDERS.map(p => ({ value: p, label: p }));
+  const selected = await clack.select({
+    message: 'LLM provider:',
+    options: providerOptions,
+    initialValue: defaultProvider || undefined,
+  });
+  if (clack.isCancel(selected)) cancelled();
+  const provider = selected;
+
+  // Model — use config as default/placeholder if available
+  const defaultModel = config.llm?.model;
+  const entered = await clack.text({
+    message: 'LLM model:',
+    placeholder: defaultModel || 'gpt-4o',
+    defaultValue: defaultModel || undefined,
+    validate: (val) => {
+      if (!val.trim()) return 'Model name is required.';
+    },
+  });
+  if (clack.isCancel(entered)) cancelled();
+  const model = entered;
 
-  // API Key
-  let apiKey: string | undefined;
-  if (bootstrapPayload.llm?.apiKey) {
-    const useBootstrap = await clack.confirm({
-      message: 'LLM API key received from dashboard. Use it?',
-      initialValue: true,
-    });
-    if (clack.isCancel(useBootstrap)) cancelled();
-    if (useBootstrap) {
-      apiKey = bootstrapPayload.llm.apiKey;
-    }
-  }
-  if (!apiKey) {
-    apiKey = config.llm?.apiKey;
-  }
-  if (!apiKey) {
-    const entered = await clack.password({
-      message: 'LLM API key:',
-      validate: (val) => {
-        if (!val.trim()) return 'API key is required.';
-      },
-    });
-    if (clack.isCancel(entered)) cancelled();
-    apiKey = entered;
-  }
+  // API Key — always prompt, never from bootstrap
+  const apiKey = await clack.password({
+    message: 'LLM API key:',
+    validate: (val) => validateLlmKeyFormat(provider, val),
+  });
+  if (clack.isCancel(apiKey)) cancelled();
 
   printDone('LLM configured');
   return { provider, model, apiKey };
@@ -180,6 +206,15 @@ async function setupLlm(
 // ---------------------------------------------------------------------------
 
 async function setupEncryption(): Promise<string> {
+  // Non-interactive mode
+  if (isNonInteractive()) {
+    const password = process.env.EXAGENT_PASSWORD;
+    if (!password || password.length < 12) {
+      throw new Error('EXAGENT_PASSWORD must be at least 12 characters in non-interactive mode');
+    }
+    return password;
+  }
+
   printInfo(`Secrets encrypted with ${pc.cyan('AES-256-GCM')} (${pc.cyan('scrypt')} KDF)`);
   printInfo('The password never leaves this machine.');
   console.log();
@@ -228,6 +263,11 @@ function writeSecureStore(path: string, secrets: LocalSecretPayload, password: s
 // ---------------------------------------------------------------------------
 
 export async function promptSecretPassword(question: string = 'Device password:'): Promise<string> {
+  if (isNonInteractive()) {
+    const password = process.env.EXAGENT_PASSWORD || process.env.EXAGENT_SECRET_PASSWORD;
+    if (!password) throw new Error('EXAGENT_PASSWORD required in non-interactive mode');
+    return password;
+  }
   const password = await clack.password({ message: question });
   if (clack.isCancel(password)) cancelled();
   return password;
@@ -248,6 +288,14 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
     !config.wallet?.privateKey &&
     !config.llm.apiKey
   ) {
+    printBanner();
+    printSuccess('Already set up', [
+      `${pc.cyan('npx exagent run')}       Start the agent`,
+      `${pc.cyan('npx exagent config')}    Change LLM API key or model`,
+      `${pc.cyan('npx exagent status')}    Check agent connection`,
+      '',
+      `${pc.dim('Dashboard:')}  ${pc.cyan('https://exagent.io')}`,
+    ]);
     return;
   }
 
@@ -260,9 +308,6 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
   const bootstrapPayload = await consumeBootstrapPackage(config);
   if (config.secrets?.bootstrapToken) {
     printDone('Bootstrap package consumed');
-    if (bootstrapPayload.llm?.provider) {
-      printInfo(`LLM config received: ${pc.cyan(bootstrapPayload.llm.provider)}${bootstrapPayload.llm.model ? ` / ${pc.cyan(bootstrapPayload.llm.model)}` : ''}`);
-    }
   } else {
     printInfo('No bootstrap token — manual configuration');
   }
@@ -273,7 +318,7 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
 
   // Step 3: LLM
   printStep(3, 4, 'LLM configuration');
-  const llm = await setupLlm(config, bootstrapPayload);
+  const llm = await setupLlm(config);
 
   // Step 4: Encryption
   printStep(4, 4, 'Device encryption');
@@ -287,15 +332,20 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
   };
 
   if (!secrets.apiToken) {
-    // Prompt for relay token if not available from bootstrap or config
-    const token = await clack.password({
-      message: 'Agent relay token:',
-      validate: (val) => {
-        if (!val.trim()) return 'Relay token is required.';
-      },
-    });
-    if (clack.isCancel(token)) cancelled();
-    secrets.apiToken = token;
+    if (isNonInteractive()) {
+      const token = process.env.EXAGENT_API_TOKEN;
+      if (!token) throw new Error('EXAGENT_API_TOKEN required in non-interactive mode (no relay token from bootstrap)');
+      secrets.apiToken = token;
+    } else {
+      const token = await clack.password({
+        message: 'Agent relay token:',
+        validate: (val) => {
+          if (!val.trim()) return 'Relay token is required.';
+        },
+      });
+      if (clack.isCancel(token)) cancelled();
+      secrets.apiToken = token;
+    }
   }
 
   const nextConfig = structuredClone(config);
@@ -324,8 +374,9 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
   clack.outro(pc.green('Setup complete'));
 
   printSuccess('Ready', [
-    `${pc.cyan('npx exagent run')}      Start trading`,
-    `${pc.cyan('npx exagent status')}   Check connection`,
+    `${pc.cyan('npx exagent run')}       Start the agent`,
+    `${pc.cyan('npx exagent config')}    Change LLM API key or model`,
+    `${pc.cyan('npx exagent status')}    Check agent connection`,
     '',
     `${pc.dim('Dashboard:')}  ${pc.cyan('https://exagent.io')}`,
   ]);