@xagent-ai/cli 1.0.1

package/src/types.ts

@@ -0,0 +1,198 @@
+export enum ExecutionMode {
+  YOLO = 'yolo',
+  ACCEPT_EDITS = 'accept_edits',
+  PLAN = 'plan',
+  DEFAULT = 'default',
+  SMART = 'smart'
+}
+
+export enum LogLevel {
+  ERROR = 'error',
+  WARN = 'warn',
+  SUCCESS = 'success',
+  INFO = 'info',
+  DEBUG = 'debug'
+}
+
+export enum AuthType {
+  OAUTH_XAGENT = 'oauth-xagent',
+  API_KEY = 'api_key',
+  OPENAI_COMPATIBLE = 'openai_compatible'
+}
+
+export interface AuthConfig {
+  type: AuthType;
+  apiKey?: string;
+  refreshToken?: string;
+  baseUrl?: string;
+  modelName?: string;
+  searchApiKey?: string;
+  showAIDebugInfo?: boolean;
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  execute: (params: any, executionMode?: ExecutionMode) => Promise<any>;
+  allowedModes: ExecutionMode[];
+  inputSchema?: any; // For MCP tools to pass input schema
+}
+
+export interface AgentConfig {
+  agentType: string;
+  systemPrompt: string;
+  whenToUse: string;
+  model?: string;
+  allowedTools?: string[];
+  allowedMcps?: string[];
+  isInheritMcps?: boolean;
+  proactive?: boolean;
+  color?: string;
+  name?: string;
+  description?: string;
+}
+
+export interface MCPServerConfig {
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  timeout?: number;
+  trust?: boolean;
+  includeTools?: string[];
+  excludeTools?: string[];
+  url?: string;
+  transport?: 'stdio' | 'sse' | 'http';
+  type?: 'stdio' | 'sse' | 'http';  // Alternative field name for transport (MCP spec compatibility)
+  authToken?: string;
+  headers?: Record<string, string>;
+}
+
+export interface CheckpointConfig {
+  enabled: boolean;
+  autoCreate: boolean;
+  maxCheckpoints: number;
+}
+
+export interface ThinkingConfig {
+  enabled: boolean;
+  mode: 'none' | 'normal' | 'hard' | 'mega' | 'ultra';
+  displayMode: 'full' | 'compact' | 'indicator';
+}
+
+export interface Settings {
+  theme: string;
+  selectedAuthType: AuthType;
+  apiKey?: string;
+  refreshToken?: string;
+  baseUrl?: string;
+  modelName?: string;
+  xagentApiBaseUrl?: string;  // xAgent API base URL (for token validation)
+  guiSubagentModel?: string;
+  guiSubagentBaseUrl?: string;
+  guiSubagentApiKey?: string;
+  searchApiKey?: string;
+  skillsPath?: string;  // Path to skills directory
+  workspacePath?: string;  // Path to workspace directory
+  executionMode: ExecutionMode;
+  approvalMode?: ExecutionMode;
+  checkpointing: CheckpointConfig;
+  thinking: ThinkingConfig;
+  contextCompression: CompressionConfig;
+  contextFileName: string | string[];
+  mcpServers: Record<string, MCPServerConfig>;
+  mcpToolPreferences: Record<string, 'mcp' | 'local'>;
+  language: 'zh' | 'en';
+  autoUpdate: boolean;
+  telemetryEnabled: boolean;
+  showToolDetails: boolean;
+  showAIDebugInfo: boolean;
+  loggerLevel: LogLevel;
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  images?: string[];
+  timestamp: number;
+  reasoningContent?: string;
+  toolCalls?: any[];
+}
+
+export interface Conversation {
+  id: string;
+  messages: ChatMessage[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface ToolCall {
+  tool: string;
+  params: any;
+  result?: any;
+  error?: string;
+  timestamp: number;
+}
+
+export interface Checkpoint {
+  id: string;
+  timestamp: number;
+  description: string;
+  gitSnapshot?: string;
+  conversationSnapshot: ChatMessage[];
+  toolCalls: ToolCall[];
+}
+
+export interface InputType {
+  type: 'text' | 'image' | 'file' | 'command';
+  content: string;
+  metadata?: any;
+}
+
+export interface SessionInput {
+  type: 'text' | 'command' | 'file' | 'image';
+  content: string;
+  rawInput?: string;
+  filePath?: string;
+  timestamp: number;
+}
+
+export interface SessionOutput {
+  role: 'assistant' | 'tool';
+  content: string;
+  toolName?: string;
+  toolParams?: any;
+  toolResult?: any;
+  timestamp: number;
+  duration?: number;
+  reasoningContent?: string;
+  toolCalls?: any[];
+}
+
+export interface Session {
+  id: string;
+  conversationId: string;
+  startTime: number;
+  endTime?: number;
+  inputs: SessionInput[];
+  outputs: SessionOutput[];
+  agent?: string;
+  executionMode?: string;
+  totalTokens?: number;
+  status: 'active' | 'completed' | 'cancelled';
+}
+
+export interface CompressionConfig {
+  enabled: boolean;
+  maxMessages: number;
+  maxContextSize: number;
+  preserveRecentMessages: number;
+  enableSummary: boolean;
+}
+
+export interface CompressionStats {
+  lastCompressionTime?: number;
+  totalCompressions: number;
+  originalMessagesTotal: number;
+  compressedMessagesTotal: number;
+}

package/src/update.ts

@@ -0,0 +1,270 @@
+import axios from 'axios';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+
+export interface VersionInfo {
+  currentVersion: string;
+  latestVersion: string;
+  updateAvailable: boolean;
+  releaseNotes?: string;
+  downloadUrl?: string;
+}
+
+export class UpdateManager {
+  private packageVersion: string;
+  private registryUrl: string;
+  private checkInterval: number;
+
+  constructor() {
+    this.packageVersion = packageJson.version;
+    this.registryUrl = 'https://registry.npmjs.org/@xagent-ai/xagent-cli';
+    this.checkInterval = 24 * 60 * 60 * 1000;
+  }
+
+  async checkForUpdates(): Promise<VersionInfo> {
+    try {
+      const response = await axios.get(this.registryUrl, {
+        timeout: 10000
+      });
+
+      const latestVersion = response.data['dist-tags'].latest;
+      const updateAvailable = this.compareVersions(this.packageVersion, latestVersion) < 0;
+
+      const versionInfo: VersionInfo = {
+        currentVersion: this.packageVersion,
+        latestVersion,
+        updateAvailable,
+        releaseNotes: response.data.versions[latestVersion]?.description,
+        downloadUrl: `https://www.npmjs.com/package/@xagent-ai/xagent-cli/v/${latestVersion}`
+      };
+
+      return versionInfo;
+    } catch (error) {
+      console.error('Failed to check for updates:', error);
+      
+      return {
+        currentVersion: this.packageVersion,
+        latestVersion: this.packageVersion,
+        updateAvailable: false
+      };
+    }
+  }
+
+  private compareVersions(v1: string, v2: string): number {
+    const normalize = (v: string) => {
+      const parts = v.replace(/^v/, '').split('-')[0].split('.');
+      return parts.map(p => parseInt(p, 10) || 0);
+    };
+
+    const v1Parts = normalize(v1);
+    const v2Parts = normalize(v2);
+
+    for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+      const v1Part = v1Parts[i] || 0;
+      const v2Part = v2Parts[i] || 0;
+
+      if (v1Part < v2Part) {
+        return -1;
+      } else if (v1Part > v2Part) {
+        return 1;
+      }
+    }
+
+    return 0;
+  }
+
+  async autoUpdate(): Promise<boolean> {
+    const versionInfo = await this.checkForUpdates();
+
+    if (!versionInfo.updateAvailable) {
+      console.log('✅ You are using the latest version');
+      return false;
+    }
+
+    console.log(`📦 Update available: ${versionInfo.currentVersion} → ${versionInfo.latestVersion}`);
+
+    if (versionInfo.releaseNotes) {
+      console.log('\nRelease Notes:');
+      console.log(versionInfo.releaseNotes);
+    }
+
+    console.log(`\nDownload: ${versionInfo.downloadUrl}`);
+
+    const { shouldUpdate } = await this.promptUpdate(versionInfo);
+
+    if (shouldUpdate) {
+      return await this.performUpdate();
+    }
+
+    return false;
+  }
+
+  private async promptUpdate(versionInfo: VersionInfo): Promise<{ shouldUpdate: boolean }> {
+    const inquirer = (await import('inquirer')).default;
+
+    const { shouldUpdate } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldUpdate',
+        message: 'Do you want to update now?',
+        default: true
+      }
+    ]);
+
+    return { shouldUpdate };
+  }
+
+  private async performUpdate(): Promise<boolean> {
+    const inquirer = (await import('inquirer')).default;
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+
+    const execAsync = promisify(exec);
+
+    try {
+      console.log('Updating xAgent CLI...');
+
+      await execAsync('npm install -g @xagent-ai/xagent-cli@latest', {
+        timeout: 120000
+      });
+
+      console.log('✅ Update successful! Please restart xAgent CLI.');
+      return true;
+    } catch (error: any) {
+      console.error('❌ Update failed:', error.message);
+
+      const { tryManual } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'tryManual',
+          message: 'Would you like to try manual update?',
+          default: false
+        }
+      ]);
+
+      if (tryManual) {
+        console.log('\nManual update instructions:');
+        console.log('1. Run: npm uninstall -g @xagent-ai/xagent-cli');
+        console.log('2. Run: npm install -g @xagent-ai/xagent-cli@latest');
+        console.log('3. Restart: xagent\n');
+      }
+
+      return false;
+    }
+  }
+
+  async checkAndNotify(): Promise<void> {
+    const versionInfo = await this.checkForUpdates();
+
+    if (versionInfo.updateAvailable) {
+      console.log(`\n📦 A new version is available: ${versionInfo.latestVersion}`);
+      console.log(`Current version: ${versionInfo.currentVersion}`);
+      console.log(`Update with: npm install -g @xagent-ai/xagent-cli@latest\n`);
+    }
+  }
+
+  getCurrentVersion(): string {
+    return this.packageVersion;
+  }
+
+  async getReleaseNotes(version?: string): Promise<string> {
+    const targetVersion = version || this.packageVersion;
+
+    try {
+      const response = await axios.get(this.registryUrl, {
+        timeout: 10000
+      });
+
+      const versionData = response.data.versions[targetVersion];
+
+      if (versionData && versionData.description) {
+        return versionData.description;
+      }
+
+      return 'No release notes available.';
+    } catch (error) {
+      console.error('Failed to fetch release notes:', error);
+      return 'Failed to fetch release notes.';
+    }
+  }
+
+  async checkUpdateOnStartup(): Promise<void> {
+    const lastCheck = await this.getLastCheckTime();
+    const now = Date.now();
+
+    if (now - lastCheck < this.checkInterval) {
+      return;
+    }
+
+    await this.checkAndNotify();
+    await this.saveLastCheckTime(now);
+  }
+
+  private async getLastCheckTime(): Promise<number> {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+
+    const filePath = path.join(os.homedir(), '.xagent', 'last-update-check');
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return parseInt(content, 10) || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  private async saveLastCheckTime(timestamp: number): Promise<void> {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+
+    const dirPath = path.join(os.homedir(), '.xagent');
+    const filePath = path.join(dirPath, 'last-update-check');
+
+    await fs.mkdir(dirPath, { recursive: true });
+    await fs.writeFile(filePath, timestamp.toString(), 'utf-8');
+  }
+
+  async forceCheckUpdate(): Promise<VersionInfo> {
+    return await this.checkForUpdates();
+  }
+
+  async enableAutoUpdate(enabled: boolean): Promise<void> {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+    const { getConfigManager } = await import('./config.js');
+
+    const configManager = getConfigManager();
+    configManager.set('autoUpdate', enabled);
+    await configManager.save('global');
+
+    console.log(`✅ Auto-update ${enabled ? 'enabled' : 'disabled'}`);
+  }
+
+  async isAutoUpdateEnabled(): Promise<boolean> {
+    const { getConfigManager } = await import('./config.js');
+    const configManager = getConfigManager();
+    return configManager.get('autoUpdate');
+  }
+}
+
+let updateManagerInstance: UpdateManager | null = null;
+
+export function getUpdateManager(): UpdateManager {
+  if (!updateManagerInstance) {
+    updateManagerInstance = new UpdateManager();
+  }
+  return updateManagerInstance;
+}
+
+export async function checkUpdatesOnStartup(): Promise<void> {
+  const updateManager = getUpdateManager();
+  
+  if (await updateManager.isAutoUpdateEnabled()) {
+    await updateManager.checkUpdateOnStartup();
+  }
+}