@meanc/otter 0.0.2 → 0.0.4

package/index.ts

@@ -7,15 +7,25 @@ import * as system from './src/commands/system';
 import * as ui from './src/commands/ui';
 import * as subscribe from './src/commands/subscribe';
 import * as menu from './src/commands/menu';
+import * as test from './src/commands/test';
+import * as connections from './src/commands/connections';
+import * as rules from './src/commands/rules';
+import * as smart from './src/commands/smart';
 import { BIN_PATH } from './src/utils/paths';
 
 const cli = cac('ot');
 
 // Core
-cli.command('up', 'Start Clash core').alias('start').action(core.start);
+cli.command('up', 'Start Clash core').alias('start').option('--smart', 'Enable smart mode').action(core.start);
 cli.command('down', 'Stop Clash core').alias('stop').action(core.stop);
 cli.command('status', 'Check status').action(core.status);
 cli.command('log', 'Show logs').action(core.log);
+cli.command('conns', 'Manage connections').alias('connections').action(connections.show);
+cli.command('match <url>', 'Check which rule matches the URL').action(rules.match);
+cli.command('smart', 'Start Smart Pilot mode').action(smart.start);
+
+// Test
+cli.command('test [group]', 'Speed test proxies').action(test.test);
 
 // Subscribe
 cli.command('sub <cmd> [arg1] [arg2]', 'Manage subscriptions')
@@ -60,7 +70,7 @@ cli.command('use [node]', 'Switch node')
   .option('-g, --global <index>', 'Select by global index')
   .option('-p, --proxy <index>', 'Select by proxy index')
   .action(proxy.use);
-cli.command('test', 'Test latency').action(proxy.test);
+// cli.command('test', 'Test latency').action(proxy.test); // Replaced by src/commands/test.ts
 cli.command('best', 'Select best node').action(proxy.best);
 
 // System
@@ -96,11 +106,11 @@ cli.help((sections) => {
 
   cli.commands.forEach(cmd => {
     const name = cmd.name.split(' ')[0] || '';
-    if (['up', 'down', 'status', 'log', 'start', 'stop'].includes(name)) {
+    if (['up', 'down', 'status', 'log', 'start', 'stop', 'conns'].includes(name)) {
       groups['Core Commands'].push(cmd);
     } else if (name === 'sub') {
       groups['Subscription Commands'].push(cmd);
-    } else if (['ls', 'use', 'test', 'best'].includes(name)) {
+    } else if (['ls', 'use', 'test', 'best', 'match', 'smart'].includes(name)) {
       groups['Proxy Commands'].push(cmd);
     } else if (['on', 'off', 'shell', 'mode'].includes(name)) {
       groups['System Commands'].push(cmd);

package/package.json

@@ -5,7 +5,7 @@
   },
   "description": "以水獭为名的clash tui",
   "module": "index.ts",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "bin": {
     "ot": "index.ts"
   },

package/src/commands/connections.tsx

@@ -0,0 +1,147 @@
+import React, { useState, useEffect } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import { ClashAPI } from '../utils/api';
+
+const formatSize = (bytes: number) => {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+const ConnectionsApp = () => {
+  const { exit } = useApp();
+  const [connections, setConnections] = useState<any[]>([]);
+  const [info, setInfo] = useState<any>({});
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [message, setMessage] = useState('');
+
+  const refresh = async () => {
+    const data = await ClashAPI.getConnections();
+    if (data) {
+      // Sort by start time (newest first)
+      const sorted = (data.connections || []).sort((a: any, b: any) => {
+        return new Date(b.start).getTime() - new Date(a.start).getTime();
+      });
+      setConnections(sorted);
+      setInfo({
+        downloadTotal: data.downloadTotal,
+        uploadTotal: data.uploadTotal,
+      });
+    }
+  };
+
+  useEffect(() => {
+    refresh();
+    const interval = setInterval(refresh, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  useInput(async (input, key) => {
+    if (input === 'q' || key.escape) {
+      exit();
+      return;
+    }
+
+    if (key.upArrow) {
+      setSelectedIndex(prev => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex(prev => Math.min(connections.length - 1, prev + 1));
+    }
+
+    if (input === 'x') {
+      if (connections.length === 0) return;
+      const conn = connections[selectedIndex];
+      setMessage(`Closing connection to ${conn.metadata.host || conn.metadata.destinationIP}...`);
+      try {
+        await ClashAPI.closeConnection(conn.id);
+        setMessage('Connection closed.');
+        // Don't wait for refresh interval
+        setTimeout(refresh, 100);
+      } catch (e: any) {
+        setMessage(`Error: ${e.message}`);
+      }
+    }
+
+    if (input === 'X') {
+      setMessage('Closing ALL connections...');
+      try {
+        await ClashAPI.closeAllConnections();
+        setMessage('All connections closed.');
+        setTimeout(refresh, 100);
+      } catch (e: any) {
+        setMessage(`Error: ${e.message}`);
+      }
+    }
+  });
+
+  const visibleRows = 15;
+  let startRow = 0;
+  if (selectedIndex > visibleRows / 2) {
+    startRow = Math.min(selectedIndex - Math.floor(visibleRows / 2), connections.length - visibleRows);
+  }
+  startRow = Math.max(0, startRow);
+  const endRow = Math.min(startRow + visibleRows, connections.length);
+  const visibleConnections = connections.slice(startRow, endRow);
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Box borderStyle="round" borderColor="blue" flexDirection="row" justifyContent="space-between" paddingX={1} marginBottom={1}>
+        <Text color="blue" bold>Active Connections: {connections.length}</Text>
+        <Box>
+          <Text>Total DL: <Text color="green">{formatSize(info.downloadTotal || 0)}</Text> | </Text>
+          <Text>Total UL: <Text color="yellow">{formatSize(info.uploadTotal || 0)}</Text></Text>
+        </Box>
+      </Box>
+
+      <Box flexDirection="column" borderStyle="single" borderColor="gray" paddingX={1} height={visibleRows + 2}>
+        <Box flexDirection="row" marginBottom={1}>
+          <Box width={30}><Text underline>Host/IP</Text></Box>
+          <Box width={20}><Text underline>Chains</Text></Box>
+          <Box width={15}><Text underline>Rule</Text></Box>
+          <Box width={15}><Text underline>Type</Text></Box>
+        </Box>
+
+        {visibleConnections.map((conn, idx) => {
+          const realIndex = startRow + idx;
+          const isSelected = realIndex === selectedIndex;
+          const host = conn.metadata.host || conn.metadata.destinationIP;
+          const chains = conn.chains.slice().reverse().join(' :: '); // Show last proxy first? No, usually first is entry.
+          // Actually chains usually: [ProxyGroup, Node].
+          const chainStr = conn.chains.length > 0 ? conn.chains[0] : 'DIRECT';
+
+          return (
+            <Box key={conn.id} flexDirection="row">
+              <Text color={isSelected ? 'cyan' : 'white'}>{isSelected ? '› ' : '  '}</Text>
+              <Box width={28}>
+                <Text color={isSelected ? 'cyan' : 'white'} wrap="truncate">
+                  {host}:{conn.metadata.destinationPort}
+                </Text>
+              </Box>
+              <Box width={20}>
+                <Text color="gray" wrap="truncate">{chainStr}</Text>
+              </Box>
+              <Box width={15}>
+                <Text color="gray" wrap="truncate">{conn.rule}</Text>
+              </Box>
+              <Box width={15}>
+                <Text color="gray">{conn.metadata.network} ({conn.metadata.type})</Text>
+              </Box>
+            </Box>
+          );
+        })}
+      </Box>
+
+      <Box borderStyle="round" borderColor="gray" paddingX={1} marginTop={1}>
+        <Text>{message || 'Arrows: Navigate | [x]: Close Selected | [X]: Close ALL | q: Quit'}</Text>
+      </Box>
+    </Box>
+  );
+};
+
+export const show = async () => {
+  const { waitUntilExit } = render(<ConnectionsApp />);
+  await waitUntilExit();
+};

package/src/commands/core.tsx

@@ -1,12 +1,13 @@
 import React, { useState, useEffect } from 'react';
-import { render, Text, Box, useApp, useInput } from 'ink';
+import { render, Text, Box, useApp, useInput, useStdout } from 'ink';
 import { CoreManager } from '../utils/core';
 import { ClashAPI } from '../utils/api';
 import { SubscriptionManager } from '../utils/subscription';
-import { LOG_FILE } from '../utils/paths';
+import { LOG_FILE, SMART_LOG_FILE, SMART_PID_FILE } from '../utils/paths';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
 import * as system from './system';
+import { TrafficGraph } from '../components/TrafficGraph';
 
 const formatSpeed = (bytes: number) => {
   if (bytes === 0) return '0 B/s';
@@ -44,10 +45,59 @@ const getSpeedPercent = (bytes: number) => {
   return Math.min(1, p);
 };
 
+const startSmartPilot = async () => {
+  // Check if already running
+  if (await fs.pathExists(SMART_PID_FILE)) {
+    try {
+      const pid = parseInt(await fs.readFile(SMART_PID_FILE, 'utf-8'), 10);
+      // Check if process exists
+      process.kill(pid, 0);
+      console.log('Smart Pilot is already running.');
+      return;
+    } catch (e) {
+      // Process doesn't exist, remove stale PID file
+      await fs.remove(SMART_PID_FILE);
+    }
+  }
+
+  await fs.ensureFile(SMART_LOG_FILE);
+  const logFd = await fs.open(SMART_LOG_FILE, 'a');
+
+  const child = spawn(process.argv[0] || 'bun', [process.argv[1] || '', 'smart'], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd]
+  }) as any;
+
+  if (child.pid) {
+    await fs.writeFile(SMART_PID_FILE, child.pid.toString());
+    child.unref();
+    console.log(`Smart Pilot started with PID ${child.pid}`);
+  } else {
+    console.error('Failed to start Smart Pilot');
+  }
+};
+
+const stopSmartPilot = async () => {
+  if (await fs.pathExists(SMART_PID_FILE)) {
+    const pid = parseInt(await fs.readFile(SMART_PID_FILE, 'utf-8'), 10);
+    if (!isNaN(pid)) {
+      try {
+        process.kill(pid);
+        console.log('Smart Pilot stopped.');
+      } catch (e) {
+        // Process might be already gone
+      }
+    }
+    await fs.remove(SMART_PID_FILE);
+  }
+};
 
-export const start = async () => {
+export const start = async (options: { smart?: boolean } = {}) => {
   try {
     await CoreManager.start();
+    if (options.smart) {
+      await startSmartPilot();
+    }
     await system.on();
   } catch (error: any) {
     console.error('Error starting core:', error.message);
@@ -61,6 +111,7 @@ export const stop = async () => {
       console.log('System proxy is enabled. Disabling it...');
       await system.off();
     }
+    await stopSmartPilot();
     await CoreManager.stop();
   } catch (error: any) {
     console.error('Error stopping core:', error.message);
@@ -70,8 +121,11 @@ export const stop = async () => {
 export const status = async () => {
   const StatusApp = () => {
     const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [width, setWidth] = useState(stdout.columns);
     const [coreStatus, setCoreStatus] = useState<any>(null);
     const [traffic, setTraffic] = useState({ up: 0, down: 0 });
+    const [history, setHistory] = useState<{ up: number[], down: number[] }>({ up: [], down: [] });
     const [subInfo, setSubInfo] = useState<{ active: string | null, count: number } | null>(null);
     const [proxyCount, setProxyCount] = useState<number>(0);
 
@@ -81,6 +135,18 @@ export const status = async () => {
       }
     });
 
+    useEffect(() => {
+      const onResize = () => setWidth(stdout.columns);
+      stdout.on('resize', onResize);
+      return () => {
+        stdout.off('resize', onResize);
+      };
+    }, [stdout]);
+
+    // Calculate dynamic graph width (terminal width - padding)
+    // Padding: marginLeft(2) + padding(1) + border(2) approx 6-8 chars
+    const graphWidth = Math.max(20, Math.min(width - 8, 120));
+
     useEffect(() => {
       let ws: WebSocket | null = null;
 
@@ -110,6 +176,12 @@ export const status = async () => {
             ws.onmessage = (event) => {
               const data = JSON.parse(event.data as string);
               setTraffic(data);
+              setHistory(prev => {
+                // Keep enough history for wide screens
+                const newUp = [...prev.up, data.up].slice(-120);
+                const newDown = [...prev.down, data.down].slice(-120);
+                return { up: newUp, down: newDown };
+              });
             };
           } catch (e) { }
         }
@@ -181,16 +253,22 @@ export const status = async () => {
           <Text color="green" bold>Network Traffic</Text>
 
           <Box marginLeft={2} marginTop={1} flexDirection="column">
-            <Box>
-              <Box width={12}><Text>Upload</Text></Box>
-              <Box width={14}><Text color="yellow">{formatSpeed(traffic.up)}</Text></Box>
-              <ProgressBar percent={getSpeedPercent(traffic.up)} width={10} color="yellow" />
+            {/* Upload Section */}
+            <Box flexDirection="column" marginBottom={1}>
+              <Box flexDirection="row" width={graphWidth} justifyContent="space-between" marginBottom={0}>
+                <Text>Upload</Text>
+                <Text color="yellow">{formatSpeed(traffic.up)}</Text>
+              </Box>
+              <TrafficGraph data={history.up} width={graphWidth} height={4} color="yellow" />
             </Box>
 
-            <Box>
-              <Box width={12}><Text>Download</Text></Box>
-              <Box width={14}><Text color="green">{formatSpeed(traffic.down)}</Text></Box>
-              <ProgressBar percent={getSpeedPercent(traffic.down)} width={10} color="green" />
+            {/* Download Section */}
+            <Box flexDirection="column">
+              <Box flexDirection="row" width={graphWidth} justifyContent="space-between" marginBottom={0}>
+                <Text>Download</Text>
+                <Text color="green">{formatSpeed(traffic.down)}</Text>
+              </Box>
+              <TrafficGraph data={history.down} width={graphWidth} height={4} color="green" />
             </Box>
           </Box>
         </Box>

package/src/commands/menu.tsx

@@ -26,7 +26,7 @@ const Menu: React.FC<MenuProps> = ({ onSelect }) => {
   return (
     <Box flexDirection="column" padding={1}>
       <Text color="green">{LOGO}</Text>
-      <Text color="gray" italic>  v0.0.1</Text>
+      <Text color="gray" italic>  v0.0.4</Text>
 
       <Box marginTop={1} marginBottom={1}>
         <Text>

package/src/commands/proxy.ts

@@ -147,7 +147,7 @@ export const test = async () => {
 };
 
 export const best = async () => {
-  console.log(chalk.blue('Testing all nodes to find the best one...'));
+  console.log(chalk.blue('Testing Proxy group to find the best one...'));
 
   const data = await ClashAPI.getProxies();
   if (!data || !data.proxies) {
@@ -156,17 +156,11 @@ export const best = async () => {
   }
 
   const proxies = data.proxies;
-  const groups = Object.values(proxies).filter((p: any) => p.type === 'Selector');
-
-  if (groups.length === 0) {
-    console.error(chalk.red('No selector groups found in config.'));
-    return;
-  }
-
-  const mainGroup: any = groups.find((g: any) => ['Proxy', 'GLOBAL'].includes(g.name)) || groups[0];
+  // Explicitly look for 'Proxy' group
+  const mainGroup: any = proxies['Proxy'];
 
   if (!mainGroup) {
-    console.error(chalk.red('Could not determine main proxy group.'));
+    console.error(chalk.red("Group 'Proxy' not found."));
     return;
   }
 

package/src/commands/rules.ts

@@ -0,0 +1,132 @@
+import { ClashAPI } from '../utils/api';
+import chalk from 'chalk';
+
+interface Rule {
+  type: string;
+  payload: string;
+  proxy: string;
+  size?: number;
+}
+
+export const match = async (urlOrHost: string) => {
+  if (!urlOrHost) {
+    console.error(chalk.red('Please provide a URL or hostname.'));
+    return;
+  }
+
+  // Clean input to get hostname
+  let hostname = urlOrHost;
+  try {
+    if (!hostname.startsWith('http')) {
+      hostname = 'http://' + hostname;
+    }
+    hostname = new URL(hostname).hostname;
+  } catch (e) {
+    console.error(chalk.red('Invalid URL or hostname.'));
+    return;
+  }
+
+  console.log(chalk.blue(`Analyzing rules for: ${chalk.bold(hostname)}`));
+
+  const config = await ClashAPI.getConfigs();
+  if (config && config.mode === 'Global') {
+    console.log(chalk.yellow('Warning: System is in Global mode. All traffic goes to GLOBAL/Proxy.'));
+  }
+
+  const baseUrl = await (ClashAPI as any).getBaseUrl();
+  const headers = await (ClashAPI as any).getHeaders();
+
+  let rules: Rule[] = [];
+  try {
+    const res = await fetch(`${baseUrl}/rules`, { headers });
+    if (!res.ok) throw new Error(res.statusText);
+    const data = await res.json() as { rules: Rule[] };
+    rules = data?.rules || [];
+  } catch (e: any) {
+    console.error(chalk.red(`Failed to fetch rules: ${e.message}`));
+    return;
+  }
+
+  console.log(chalk.gray(`Loaded ${rules.length} rules.`));
+
+  let matchedRule: Rule | null = null;
+
+  for (const rule of rules) {
+    const type = rule.type.toLowerCase();
+    const payload = rule.payload;
+    const lowerHost = hostname.toLowerCase();
+    const lowerPayload = payload.toLowerCase();
+
+    let isMatch = false;
+
+    switch (type) {
+      case 'domain':
+        isMatch = lowerHost === lowerPayload;
+        break;
+      case 'domainsuffix':
+      case 'domain-suffix':
+        isMatch = lowerHost === lowerPayload || lowerHost.endsWith('.' + lowerPayload);
+        break;
+      case 'domainkeyword':
+      case 'domain-keyword':
+        isMatch = lowerHost.includes(lowerPayload);
+        break;
+      case 'match':
+        isMatch = true;
+        break;
+      case 'geoip':
+      case 'ip-cidr':
+      case 'ip-cidr6':
+        // Cannot match IP rules without DNS resolution
+        // We skip them but maybe log a warning if verbose
+        break;
+      default:
+        break;
+    }
+
+    if (isMatch) {
+      matchedRule = rule;
+      break; // Clash uses first match
+    }
+  }
+
+  if (matchedRule) {
+    console.log('');
+    console.log(chalk.green('✔ Match Found!'));
+    console.log('─'.repeat(30));
+    console.log(`Type:    ${chalk.cyan(matchedRule.type)}`);
+    console.log(`Payload: ${chalk.yellow(matchedRule.payload || '(Final)')}`);
+    console.log(`Proxy:   ${chalk.magenta(matchedRule.proxy)}`);
+
+    // Resolve Proxy Details
+    try {
+      const proxyData = await ClashAPI.getProxies();
+      if (proxyData && proxyData.proxies) {
+        const proxyName = matchedRule.proxy;
+        const proxyInfo = proxyData.proxies[proxyName];
+
+        if (proxyInfo) {
+          console.log(`   └─ Type: ${proxyInfo.type}`);
+          if (proxyInfo.now) {
+            console.log(`   └─ Now:  ${chalk.green(proxyInfo.now)}`);
+          }
+          // If the 'now' node is also a group, we could recurse, but one level is usually enough context
+          if (proxyInfo.now && proxyData.proxies[proxyInfo.now]) {
+            const nextHop = proxyData.proxies[proxyInfo.now];
+            if (nextHop.type === 'Selector' || nextHop.type === 'URLTest') {
+              console.log(`      └─ Next: ${chalk.green(nextHop.now)}`);
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore proxy resolution errors
+    }
+
+    console.log('─'.repeat(30));
+  } else {
+    console.log('');
+    console.log(chalk.red('✘ No matching rule found (and no Match rule present?).'));
+    console.log('Traffic might fall through to default behavior.');
+  }
+};

package/src/commands/smart.ts

@@ -0,0 +1,151 @@
+import { ClashAPI } from '../utils/api';
+import { SubscriptionManager } from '../utils/subscription';
+import * as system from './system';
+import chalk from 'chalk';
+
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+const findBestNode = async (nodes: string[]): Promise<{ name: string, delay: number } | null> => {
+  if (nodes.length === 0) return null;
+
+  // Test up to 5 nodes concurrently to save time
+  const candidates = nodes.slice(0, 5);
+
+  const results = await Promise.all(candidates.map(async (node) => {
+    try {
+      const res = await ClashAPI.getDelay(node) as { delay: number };
+      return { name: node, delay: res.delay };
+    } catch {
+      return { name: node, delay: Infinity };
+    }
+  }));
+
+  // Filter valid results and sort
+  const valid = results.filter(r => r.delay < 2000).sort((a, b) => a.delay - b.delay);
+
+  if (valid.length > 0) {
+    const best = valid[0];
+    if (best) {
+      return { name: best.name, delay: best.delay };
+    }
+  }
+  return null;
+};
+
+export const start = async () => {
+  console.log(chalk.cyan(chalk.bold('🦦 Otter Smart Pilot Initiated')));
+  console.log(chalk.gray('Monitoring network health and managing failover...'));
+  console.log(chalk.gray('Press Ctrl+C to stop.'));
+  console.log('─'.repeat(40));
+
+  while (true) {
+    try {
+      // 1. Health Check
+      const data = await ClashAPI.getProxies();
+      if (!data || !data.proxies) {
+        console.log(chalk.red('Otter Core not reachable. Retrying in 5s...'));
+        await sleep(5000);
+        continue;
+      }
+
+      const proxyGroup = data.proxies['Proxy'];
+      if (!proxyGroup) {
+        console.log(chalk.red("Group 'Proxy' not found."));
+        await sleep(10000);
+        continue;
+      }
+
+      const currentNode = proxyGroup.now;
+      process.stdout.write(`[${new Date().toLocaleTimeString()}] Checking ${currentNode}... `);
+
+      let isHealthy = false;
+      try {
+        const res = await ClashAPI.getDelay(currentNode) as { delay: number };
+        if (res.delay < 1500) {
+          console.log(chalk.green(`OK (${res.delay}ms)`));
+          isHealthy = true;
+        } else {
+          console.log(chalk.yellow(`High Latency (${res.delay}ms)`));
+        }
+      } catch {
+        console.log(chalk.red('Timeout'));
+      }
+
+      if (isHealthy) {
+        await sleep(10000); // Check every 10s if healthy
+        continue;
+      }
+
+      // 2. Fallback Logic
+      console.log(chalk.yellow('⚠ Connection unstable. Initiating fallback protocol...'));
+
+      const allNodes: string[] = proxyGroup.all;
+
+      // Regex patterns
+      const regions = [
+        { name: 'Hong Kong', regex: /HK|Hong Kong|香港/i },
+        { name: 'Japan', regex: /JP|Japan|日本/i },
+        { name: 'USA', regex: /US|USA|United States|美国/i },
+      ];
+
+      let fallbackSuccess = false;
+
+      for (const region of regions) {
+        console.log(chalk.blue(`Searching for healthy ${region.name} nodes...`));
+        const regionNodes = allNodes.filter(n => region.regex.test(n));
+
+        const best = await findBestNode(regionNodes);
+        if (best) {
+          console.log(chalk.green(`✔ Found ${region.name} node: ${best.name} (${best.delay}ms)`));
+          await ClashAPI.switchProxy('Proxy', best.name);
+          console.log(chalk.green(`Switched to ${best.name}`));
+          fallbackSuccess = true;
+          break;
+        } else {
+          console.log(chalk.gray(`✘ No healthy ${region.name} nodes found.`));
+        }
+      }
+
+      if (fallbackSuccess) {
+        await sleep(5000); // Wait a bit before next check
+        continue;
+      }
+
+      // 3. Disaster Recovery
+      console.log(chalk.red.bold('‼ All fallback regions failed. Initiating EMERGENCY UPDATE...'));
+
+      console.log(chalk.yellow('1. Disabling System Proxy...'));
+      await system.off(true); // silent
+
+      console.log(chalk.yellow('2. Updating Subscriptions...'));
+      const subData = await SubscriptionManager.getData();
+      for (const sub of subData.subscriptions) {
+        process.stdout.write(`Updating ${sub.name}... `);
+        try {
+          await SubscriptionManager.update(sub.name);
+          console.log(chalk.green('Done'));
+        } catch (e: any) {
+          console.log(chalk.red('Failed'));
+        }
+      }
+
+      console.log(chalk.yellow('3. Re-enabling System Proxy...'));
+      await system.on(true);
+
+      console.log(chalk.yellow('4. Selecting Best Node...'));
+      // Simple best node selection from all nodes
+      const bestAny = await findBestNode(allNodes);
+      if (bestAny) {
+        await ClashAPI.switchProxy('Proxy', bestAny.name);
+        console.log(chalk.green(`Recovered! Switched to ${bestAny.name}`));
+      } else {
+        console.log(chalk.red('Recovery failed. No reachable nodes found. Retrying in 1 minute...'));
+        await sleep(60000);
+      }
+
+    } catch (e: any) {
+      console.error(chalk.red(`Smart Pilot Error: ${e.message}`));
+      await sleep(5000);
+    }
+  }
+};

package/src/commands/system.ts

@@ -134,7 +134,7 @@ export const mode = async (modeName?: string) => {
     return;
   }
 
-  const validModes = ['global', 'rule', 'direct'];
+  const validModes = ['global', 'rule', 'direct', 'script'];
   const m = modeName.toLowerCase();
   if (!validModes.includes(m)) {
     console.error(chalk.red(`Invalid mode: ${modeName}. Valid modes: ${validModes.join(', ')}`));

package/src/commands/test.ts

@@ -0,0 +1,70 @@
+import { ClashAPI } from '../utils/api';
+import chalk from 'chalk';
+
+export const test = async (target: string = 'Proxy') => {
+  console.log(chalk.blue(`Testing latency for: ${target}...`));
+
+  const data = await ClashAPI.getProxies();
+  if (!data || !data.proxies) {
+    console.error(chalk.red('Failed to fetch proxies. Is Otter running?'));
+    return;
+  }
+
+  const item = data.proxies[target];
+  if (!item) {
+    console.error(chalk.red(`Proxy or Group '${target}' not found.`));
+    const availableGroups = Object.values(data.proxies)
+      .filter((p: any) => p.type === 'Selector')
+      .map((p: any) => p.name)
+      .join(', ');
+    console.log(chalk.gray(`Available groups: ${availableGroups}`));
+    return;
+  }
+
+  let nodes: string[] = [];
+  if (item.all && Array.isArray(item.all)) {
+    nodes = item.all;
+  } else {
+    // It's a single node
+    nodes = [target];
+  }
+
+  console.log(chalk.bold(`Starting speed test for ${nodes.length} nodes...`));
+  console.log('─'.repeat(40));
+
+  const printResult = (name: string, delay: number | string) => {
+    let delayDisplay = '';
+    let nameDisplay = name;
+
+    if (typeof delay === 'number') {
+      const ms = delay;
+      let color = chalk.green;
+      if (ms > 400) color = chalk.yellow;
+      if (ms > 1000) color = chalk.red;
+
+      delayDisplay = color(`${ms}ms`.padEnd(8));
+    } else {
+      delayDisplay = chalk.gray('Timeout '.padEnd(8));
+      nameDisplay = chalk.gray(name);
+    }
+
+    console.log(`${delayDisplay} ${nameDisplay}`);
+  };
+
+  // Process in batches
+  const batchSize = 10;
+  for (let i = 0; i < nodes.length; i += batchSize) {
+    const batch = nodes.slice(i, i + batchSize);
+    await Promise.all(batch.map(async (node) => {
+      try {
+        const res = await ClashAPI.getDelay(node) as { delay: number };
+        printResult(node, res.delay);
+      } catch (e) {
+        printResult(node, 'Timeout');
+      }
+    }));
+  }
+
+  console.log('─'.repeat(40));
+  console.log(chalk.green('Test completed.'));
+};

package/src/commands/ui.tsx

@@ -178,6 +178,49 @@ const TuiApp = () => {
       return;
     }
 
+    if (input === 'b') {
+      if (groups.length === 0) return;
+      const currentGroup = groups[selectedGroupIndex];
+      setMessage(`Testing ${currentGroup.name} for best node...`);
+
+      // Run test in background
+      (async () => {
+        try {
+          const candidates: string[] = currentGroup.all;
+          let bestNode = '';
+          let minDelay = Infinity;
+
+          // Test all nodes
+          const results = await Promise.all(candidates.map(async (node) => {
+            try {
+              const res = await ClashAPI.getDelay(node);
+              return { node, delay: res.delay };
+            } catch {
+              return { node, delay: Infinity };
+            }
+          }));
+
+          results.forEach(r => {
+            if (r.delay < minDelay && r.delay > 0) {
+              minDelay = r.delay;
+              bestNode = r.node;
+            }
+          });
+
+          if (bestNode) {
+            await ClashAPI.switchProxy(currentGroup.name, bestNode);
+            setMessage(`Auto-selected: ${bestNode} (${minDelay}ms)`);
+            await refreshProxies();
+          } else {
+            setMessage('No reachable nodes found.');
+          }
+        } catch (e: any) {
+          setMessage(`Error: ${e.message}`);
+        }
+      })();
+      return;
+    }
+
     if (groups.length === 0) return;
 
     const currentGroup = groups[selectedGroupIndex];
@@ -310,7 +353,7 @@ const TuiApp = () => {
 
       {/* Footer / Status Bar */}
       <Box borderStyle="round" borderColor="gray" paddingX={1}>
-        <Text>{message || 'Arrows: Navigate | Enter: Select | Tab: Switch Panel | [s]: SysProxy | [m]: Mode | q: Quit'}</Text>
+        <Text>{message || 'Arrows: Navigate | Enter: Select | Tab: Switch Panel | [s]: SysProxy | [m]: Mode | [b]: Best | q: Quit'}</Text>
       </Box>
     </Box>
   );

package/src/components/TrafficGraph.tsx

@@ -0,0 +1,70 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+
+interface TrafficGraphProps {
+  data: number[];
+  width?: number;
+  height?: number;
+  color?: string;
+  max?: number;
+}
+
+const formatSize = (bytes: number) => {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + (sizes[i] || 'B');
+};
+
+export const TrafficGraph: React.FC<TrafficGraphProps> = ({
+  data,
+  width = 40,
+  height = 4,
+  color = 'green',
+  max
+}) => {
+  // Pad with 0s at the start if data is less than width
+  const filledData = [...(new Array(Math.max(0, width - data.length)).fill(0)), ...data].slice(-width);
+
+  // Calculate max value for scaling
+  // Use a minimum max value (e.g. 1KB) to avoid flat lines on 0
+  const maxValue = max || Math.max(...filledData, 1024);
+
+  const rows = [];
+  const chars = [' ', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+
+  for (let y = height - 1; y >= 0; y--) {
+    let rowStr = '';
+    for (let x = 0; x < width; x++) {
+      const value = filledData[x];
+      const ratio = value / maxValue;
+      const scaledValue = ratio * height;
+
+      if (scaledValue >= y + 1) {
+        rowStr += '█';
+      } else if (scaledValue > y) {
+        const remainder = scaledValue - y;
+        const charIndex = Math.floor(remainder * (chars.length - 1));
+        rowStr += chars[charIndex];
+      } else {
+        rowStr += ' ';
+      }
+    }
+    rows.push(rowStr);
+  }
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="gray" paddingX={1}>
+      <Box flexDirection="column">
+        {rows.map((row, i) => (
+          <Text key={i} color={color}>{row}</Text>
+        ))}
+      </Box>
+      <Box justifyContent="space-between" marginTop={0}>
+        <Text color="gray" dimColor>0</Text>
+        <Text color="gray" dimColor>{formatSize(maxValue)}</Text>
+      </Box>
+    </Box>
+  );
+};

package/src/utils/api.ts

@@ -100,6 +100,38 @@ export class ClashAPI {
     if (!res.ok) throw new Error(`Failed to update config: ${res.statusText}`);
   }
 
+  static async getConnections(): Promise<any> {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    try {
+      const res = await fetch(`${baseUrl}/connections`, { headers });
+      if (!res.ok) throw new Error(`API Error: ${res.statusText}`);
+      return await res.json();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static async closeConnection(id: string) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const res = await fetch(`${baseUrl}/connections/${id}`, {
+      method: 'DELETE',
+      headers
+    });
+    if (!res.ok) throw new Error(`Failed to close connection: ${res.statusText}`);
+  }
+
+  static async closeAllConnections() {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const res = await fetch(`${baseUrl}/connections`, {
+      method: 'DELETE',
+      headers
+    });
+    if (!res.ok) throw new Error(`Failed to close all connections: ${res.statusText}`);
+  }
+
   static async getTrafficUrl(): Promise<string> {
     const baseUrl = await this.getBaseUrl();
     return baseUrl.replace('http://', 'ws://') + '/traffic';

package/src/utils/paths.ts

@@ -4,7 +4,9 @@ import os from 'os';
 export const HOME_DIR = path.join(os.homedir(), '.otter');
 export const CONFIG_FILE = path.join(HOME_DIR, 'config.yaml');
 export const PID_FILE = path.join(HOME_DIR, 'otter.pid');
+export const SMART_PID_FILE = path.join(HOME_DIR, 'smart.pid');
 export const LOG_FILE = path.join(HOME_DIR, 'otter.log');
+export const SMART_LOG_FILE = path.join(HOME_DIR, 'smart.log');
 export const BIN_PATH = path.resolve(import.meta.dir, '../../bin/mihomo');
 export const SUBSCRIPTIONS_FILE = path.join(HOME_DIR, 'subscriptions.json');
 export const PROFILES_DIR = path.join(HOME_DIR, 'profiles');