@meanc/otter 0.0.1 → 0.0.3

package/README.md

@@ -3,6 +3,11 @@
 Otter (ot) 是一个基于 [Mihomo](https://github.com/MetaCubeX/mihomo)
 核心的极简主义 Clash TUI
 客户端。它专为速度和可组合性而设计，提供流畅的命令行体验和交互式界面。
+<img width="1036" height="532" alt="image" src="https://github.com/user-attachments/assets/3d2969ed-41ee-4bd3-b37a-97173bea2d50" />
+
+<img width="658" height="426" alt="image" src="https://github.com/user-attachments/assets/e82dfb1a-3548-45b4-be99-6f4a3bf1ea43" />
+
+
 
 ## ✨ 特性
 

package/bun.lock

@@ -10,6 +10,7 @@
         "chalk": "^5.6.2",
         "fs-extra": "^11.3.3",
         "ink": "^6.5.1",
+        "ink-select-input": "^6.2.0",
         "js-yaml": "^4.1.1",
         "ps-list": "^9.0.0",
         "react": "^19.2.3",
@@ -77,6 +78,8 @@
 
     "escape-string-regexp": ["escape-string-regexp@2.0.0", "", {}, "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w=="],
 
+    "figures": ["figures@6.1.0", "", { "dependencies": { "is-unicode-supported": "^2.0.0" } }, "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg=="],
+
     "fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="],
 
     "get-east-asian-width": ["get-east-asian-width@1.4.0", "", {}, "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q=="],
@@ -87,10 +90,14 @@
 
     "ink": ["ink@6.5.1", "", { "dependencies": { "@alcalzone/ansi-tokenize": "^0.2.1", "ansi-escapes": "^7.2.0", "ansi-styles": "^6.2.1", "auto-bind": "^5.0.1", "chalk": "^5.6.0", "cli-boxes": "^3.0.0", "cli-cursor": "^4.0.0", "cli-truncate": "^5.1.1", "code-excerpt": "^4.0.0", "es-toolkit": "^1.39.10", "indent-string": "^5.0.0", "is-in-ci": "^2.0.0", "patch-console": "^2.0.0", "react-reconciler": "^0.33.0", "signal-exit": "^3.0.7", "slice-ansi": "^7.1.0", "stack-utils": "^2.0.6", "string-width": "^8.1.0", "type-fest": "^4.27.0", "widest-line": "^5.0.0", "wrap-ansi": "^9.0.0", "ws": "^8.18.0", "yoga-layout": "~3.2.1" }, "peerDependencies": { "@types/react": ">=19.0.0", "react": ">=19.0.0", "react-devtools-core": "^6.1.2" }, "optionalPeers": ["@types/react", "react-devtools-core"] }, "sha512-wF3j/DmkM8q5E+OtfdQhCRw8/0ahkc8CUTgEddxZzpEWPslu7YPL3t64MWRoI9m6upVGpfAg4ms2BBvxCdKRLQ=="],
 
+    "ink-select-input": ["ink-select-input@6.2.0", "", { "dependencies": { "figures": "^6.1.0", "to-rotated": "^1.0.0" }, "peerDependencies": { "ink": ">=5.0.0", "react": ">=18.0.0" } }, "sha512-304fZXxkpYxJ9si5lxRCaX01GNlmPBgOZumXXRnPYbHW/iI31cgQynqk2tRypGLOF1cMIwPUzL2LSm6q4I5rQQ=="],
+
     "is-fullwidth-code-point": ["is-fullwidth-code-point@5.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="],
 
     "is-in-ci": ["is-in-ci@2.0.0", "", { "bin": { "is-in-ci": "cli.js" } }, "sha512-cFeerHriAnhrQSbpAxL37W1wcJKUUX07HyLWZCW1URJT/ra3GyUTzBgUnh24TMVfNTV2Hij2HLxkPHFZfOZy5w=="],
 
+    "is-unicode-supported": ["is-unicode-supported@2.1.0", "", {}, "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ=="],
+
     "js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="],
 
     "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="],
@@ -121,6 +128,8 @@
 
     "strip-ansi": ["strip-ansi@7.1.2", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA=="],
 
+    "to-rotated": ["to-rotated@1.0.0", "", {}, "sha512-KsEID8AfgUy+pxVRLsWp0VzCa69wxzUDZnzGbyIST/bcgcrMvTYoFBX/QORH4YApoD89EDuUovx4BTdpOn319Q=="],
+
     "type-fest": ["type-fest@4.41.0", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="],
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],

package/index.ts

@@ -6,15 +6,26 @@ import * as proxy from './src/commands/proxy';
 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')
@@ -59,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
@@ -95,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);
@@ -138,4 +149,30 @@ cli.help((sections) => {
   return newSections;
 });
 
-cli.parse();
+const run = async () => {
+  // If no args provided, show menu
+  if (process.argv.length === 2) {
+    const action = await menu.show();
+    switch (action) {
+      case 'start':
+        await core.start();
+        break;
+      case 'stop':
+        await core.stop();
+        break;
+      case 'status':
+        await core.status();
+        break;
+      case 'ui':
+        await ui.ui();
+        break;
+      case 'quit':
+        process.exit(0);
+        break;
+    }
+  } else {
+    cli.parse();
+  }
+};
+
+run();

package/package.json

@@ -5,7 +5,7 @@
   },
   "description": "以水獭为名的clash tui",
   "module": "index.ts",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "bin": {
     "ot": "index.ts"
   },
@@ -28,6 +28,7 @@
     "chalk": "^5.6.2",
     "fs-extra": "^11.3.3",
     "ink": "^6.5.1",
+    "ink-select-input": "^6.2.0",
     "js-yaml": "^4.1.1",
     "ps-list": "^9.0.0",
     "react": "^19.2.3",

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,11 +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';
@@ -23,9 +25,80 @@ const formatSize = (bytes: number) => {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 };
 
-export const start = async () => {
+const ProgressBar = ({ percent = 0, width = 20, color = 'green' }: { percent?: number, width?: number, color?: string }) => {
+  const safePercent = Math.min(1, Math.max(0, percent));
+  const completed = Math.floor(safePercent * width);
+  const remaining = width - completed;
+  return (
+    <Text>
+      <Text color={color}>{'█'.repeat(completed)}</Text>
+      <Text color="gray">{'░'.repeat(remaining)}</Text>
+    </Text>
+  );
+};
+
+const getSpeedPercent = (bytes: number) => {
+  if (bytes <= 0) return 0;
+  const MAX_SPEED = 10 * 1024 * 1024; // 10MB/s
+  // Linear scale
+  const p = bytes / MAX_SPEED;
+  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 (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);
   }
@@ -33,6 +106,12 @@ export const start = async () => {
 
 export const stop = async () => {
   try {
+    const isProxyEnabled = await system.getSystemProxyStatus();
+    if (isProxyEnabled) {
+      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);
@@ -42,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);
 
@@ -53,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;
 
@@ -82,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) { }
         }
@@ -105,57 +205,71 @@ export const status = async () => {
 
     if (!coreStatus.running) {
       return (
-        <Box borderStyle="round" borderColor="red" padding={1}>
-          <Text color="red">Otter Core is stopped.</Text>
+        <Box padding={1}>
+          <Text color="red">● Otter Core is stopped.</Text>
         </Box>
       );
     }
 
     return (
-      <Box flexDirection="column" borderStyle="round" borderColor="green" padding={1} width={50}>
-        <Box justifyContent="space-between">
-          <Text color="green" bold>Otter Core is running</Text>
-          <Text color="gray">Press 'q' to exit</Text>
+      <Box flexDirection="column" padding={1}>
+        <Box marginBottom={1}>
+          <Text color="cyan" bold>● Otter Status</Text>
+          <Text color="gray">  (Press 'q' to exit)</Text>
         </Box>
 
-        <Box marginTop={1} flexDirection="column">
-          <Box>
-            <Box width={12}><Text>PID:</Text></Box>
-            <Text color="blue">{coreStatus.pid}</Text>
+        {/* System Info */}
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color="blue" bold>System</Text>
+          <Box marginLeft={2}>
+            <Box width={12}><Text>PID</Text></Box>
+            <Text color="gray">{coreStatus.pid}</Text>
           </Box>
-          <Box>
-            <Box width={12}><Text>Version:</Text></Box>
-            <Text color="yellow">{coreStatus.version}</Text>
+          <Box marginLeft={2}>
+            <Box width={12}><Text>Version</Text></Box>
+            <Text color="gray">{coreStatus.version}</Text>
           </Box>
-          <Box>
-            <Box width={12}><Text>Memory:</Text></Box>
-            <Text color="cyan">{formatSize(coreStatus.memory || 0)}</Text>
+          <Box marginLeft={2}>
+            <Box width={12}><Text>Memory</Text></Box>
+            <Text color="gray">{formatSize(coreStatus.memory || 0)}</Text>
           </Box>
         </Box>
 
-        <Box marginTop={1} borderStyle="single" borderColor="gray" flexDirection="column">
-          <Box>
-            <Box width={12}><Text>Active Sub:</Text></Box>
-            <Text color="magenta">{subInfo?.active || 'None'}</Text>
-          </Box>
-          <Box>
-            <Box width={12}><Text>Total Subs:</Text></Box>
-            <Text>{subInfo?.count || 0}</Text>
+        {/* Configuration */}
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color="magenta" bold>Configuration</Text>
+          <Box marginLeft={2}>
+            <Box width={12}><Text>Profile</Text></Box>
+            <Text color="gray">{subInfo?.active || 'Default'}</Text>
           </Box>
-          <Box>
-            <Box width={12}><Text>Proxies:</Text></Box>
-            <Text>{proxyCount}</Text>
+          <Box marginLeft={2}>
+            <Box width={12}><Text>Proxies</Text></Box>
+            <Text color="gray">{proxyCount} nodes</Text>
           </Box>
         </Box>
 
-        <Box marginTop={1} flexDirection="row" justifyContent="space-around">
-          <Box flexDirection="column" alignItems="center">
-            <Text>Upload</Text>
-            <Text color="green">↑ {formatSpeed(traffic.up)}</Text>
-          </Box>
-          <Box flexDirection="column" alignItems="center">
-            <Text>Download</Text>
-            <Text color="green">↓ {formatSpeed(traffic.down)}</Text>
+        {/* Network Traffic */}
+        <Box flexDirection="column">
+          <Text color="green" bold>Network Traffic</Text>
+
+          <Box marginLeft={2} marginTop={1} flexDirection="column">
+            {/* 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>
+
+            {/* 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>
       </Box>

package/src/commands/menu.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { render, Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+
+const LOGO = `
+   ____  __  __
+  / __ \\/ /_/ /____  _____
+ / / / / __/ __/ _ \\/ ___/
+/ /_/ / /_/ /_/  __/ /
+\\____/\\__/\\__/\\___/_/
+`;
+
+interface MenuProps {
+  onSelect: (value: string) => void;
+}
+
+const Menu: React.FC<MenuProps> = ({ onSelect }) => {
+  const items = [
+    { label: 'Start'.padEnd(15) + 'Start Clash core & System Proxy', value: 'start' },
+    { label: 'Stop'.padEnd(15) + 'Stop Clash core & Disable Proxy', value: 'stop' },
+    { label: 'Status'.padEnd(15) + 'Check status & traffic', value: 'status' },
+    { label: 'Dashboard'.padEnd(15) + 'Launch full TUI', value: 'ui' },
+    { label: 'Quit'.padEnd(15) + 'Exit', value: 'quit' },
+  ];
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text color="green">{LOGO}</Text>
+      <Text color="gray" italic>  v0.0.1</Text>
+
+      <Box marginTop={1} marginBottom={1}>
+        <Text>
+          <Text color="cyan">➤</Text> Use <Text bold>Arrow Keys</Text> to select and <Text bold>Enter</Text> to confirm
+        </Text>
+      </Box>
+
+      <SelectInput
+        items={items}
+        onSelect={(item) => onSelect(item.value)}
+        indicatorComponent={({ isSelected }) => (
+          <Text color={isSelected ? 'cyan' : 'gray'}>
+            {isSelected ? '➤ ' : '  '}
+          </Text>
+        )}
+        itemComponent={({ isSelected, label }) => (
+          <Text color={isSelected ? 'cyan' : 'white'}>
+            {label}
+          </Text>
+        )}
+      />
+
+      <Box marginTop={1} borderStyle="single" borderColor="gray" paddingX={1}>
+        <Text color="gray">
+          <Text>↑↓</Text> Navigate | <Text>Enter</Text> Select | <Text>Q</Text> Quit
+        </Text>
+      </Box>
+    </Box>
+  );
+};
+
+export const show = () => {
+  return new Promise<string>((resolve) => {
+    const { unmount } = render(<Menu onSelect={(value) => {
+      unmount();
+      resolve(value);
+    }} />);
+  });
+};

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');