@meanc/otter 0.0.1

package/src/commands/ui.tsx

@@ -0,0 +1,322 @@
+import React, { useState, useEffect } from 'react';
+import { render, Box, Text, useInput, useApp, Spacer } from 'ink';
+import { ClashAPI } from '../utils/api';
+import { CoreManager } from '../utils/core';
+import { on, off, getSystemProxyStatus } from './system';
+
+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 ProxyListStatic = ({ groups, mode }: { groups: any[], mode: string }) => {
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Box marginBottom={1}>
+        <Text>Current Mode: </Text>
+        <Text color="yellow" bold>{mode.toUpperCase()}</Text>
+      </Box>
+      {groups.map((group) => {
+        let itemIndex = 0;
+        const isProxy = group.name === 'Proxy';
+        const isGlobal = group.name === 'GLOBAL';
+
+        return (
+          <Box key={group.name} flexDirection="column" marginBottom={1}>
+            <Text bold color="cyan">
+              ┌ {group.name}
+            </Text>
+            {group.all.map((node: string) => {
+              itemIndex++;
+              const isSelected = group.now === node;
+              let indexLabel = '   ';
+              if (isProxy) indexLabel = `P${itemIndex}`.padEnd(4);
+              else if (isGlobal) indexLabel = `G${itemIndex}`.padEnd(4);
+
+              return (
+                <Box key={node}>
+                  <Text color="gray">│ </Text>
+                  <Text color="gray">{indexLabel}</Text>
+                  <Text color={isSelected ? 'green' : 'white'}>
+                    {isSelected ? '● ' : '○ '} {node}
+                  </Text>
+                </Box>
+              );
+            })}
+            <Text color="gray">└{'─'.repeat(20)}</Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+};
+
+const LSApp = ({ groups, mode }: { groups: any[], mode: string }) => {
+  const { exit } = useApp();
+  useEffect(() => {
+    exit();
+  }, []);
+  return <ProxyListStatic groups={groups} mode={mode} />;
+};
+
+export const renderLS = async () => {
+  const [data, config] = await Promise.all([
+    ClashAPI.getProxies(),
+    ClashAPI.getConfigs()
+  ]);
+
+  if (!data || !data.proxies) {
+    console.log('Failed to fetch proxies. Is Otter running?');
+    return;
+  }
+
+  const mode = config?.mode || 'Unknown';
+
+  const g = Object.values(data.proxies).filter((p: any) => p.type === 'Selector');
+  g.sort((a: any, b: any) => {
+    if (['Proxy', 'GLOBAL'].includes(a.name)) return -1;
+    if (['Proxy', 'GLOBAL'].includes(b.name)) return 1;
+    return 0;
+  });
+
+  const { waitUntilExit } = render(<LSApp groups={g} mode={mode} />);
+  await waitUntilExit();
+};
+
+const TuiApp = () => {
+  const { exit } = useApp();
+  const [proxies, setProxies] = useState<any>(null);
+  const [groups, setGroups] = useState<any[]>([]);
+  const [selectedGroupIndex, setSelectedGroupIndex] = useState(0);
+  const [selectedNodeIndex, setSelectedNodeIndex] = useState(0);
+  const [status, setStatus] = useState<any>(null);
+  const [mode, setMode] = useState<string>('');
+  const [systemProxyEnabled, setSystemProxyEnabled] = useState(false);
+  const [message, setMessage] = useState('');
+  const [activeTab, setActiveTab] = useState<'groups' | 'nodes'>('groups'); // Focus control
+
+  useEffect(() => {
+    const init = async () => {
+      const s = await CoreManager.getStatus();
+      setStatus(s);
+      const sysStatus = await getSystemProxyStatus();
+      setSystemProxyEnabled(sysStatus);
+      if (s.running) {
+        await refreshProxies();
+        const c = await ClashAPI.getConfigs();
+        if (c) setMode(c.mode);
+      }
+    };
+    init();
+    // Auto refresh status every 5s
+    const interval = setInterval(async () => {
+      const s = await CoreManager.getStatus();
+      setStatus(s);
+      const sysStatus = await getSystemProxyStatus();
+      setSystemProxyEnabled(sysStatus);
+      if (s.running) {
+        const c = await ClashAPI.getConfigs();
+        if (c) setMode(c.mode);
+      }
+    }, 5000);
+    return () => clearInterval(interval);
+  }, []);
+
+  const refreshProxies = async () => {
+    const data = await ClashAPI.getProxies();
+    if (data && data.proxies) {
+      setProxies(data.proxies);
+      const g = Object.values(data.proxies).filter((p: any) => p.type === 'Selector');
+      // Sort to put Proxy/GLOBAL first
+      g.sort((a: any, b: any) => {
+        if (['Proxy', 'GLOBAL'].includes(a.name)) return -1;
+        if (['Proxy', 'GLOBAL'].includes(b.name)) return 1;
+        return 0;
+      });
+      setGroups(g);
+    }
+  };
+
+  useInput(async (input, key) => {
+    if (key.escape || input === 'q') {
+      exit();
+      return;
+    }
+
+    if (input === 's') {
+      setMessage(systemProxyEnabled ? 'Disabling System Proxy...' : 'Enabling System Proxy...');
+      try {
+        if (systemProxyEnabled) {
+          await off(true);
+        } else {
+          await on(true);
+        }
+        const sysStatus = await getSystemProxyStatus();
+        setSystemProxyEnabled(sysStatus);
+        setMessage(sysStatus ? 'System Proxy Enabled' : 'System Proxy Disabled');
+      } catch (e: any) {
+        setMessage(`Error: ${e.message}`);
+      }
+      return;
+    }
+
+    if (input === 'm') {
+      const modes = ['Rule', 'Global', 'Direct'];
+      const currentModeIndex = modes.findIndex(m => m.toLowerCase() === mode.toLowerCase());
+      const nextMode = modes[(currentModeIndex + 1) % modes.length] || 'Rule';
+      setMessage(`Switching mode to ${nextMode}...`);
+      try {
+        await ClashAPI.updateConfig({ mode: nextMode });
+        setMode(nextMode);
+        setMessage(`Mode switched to ${nextMode}`);
+      } catch (e: any) {
+        setMessage(`Error: ${e.message}`);
+      }
+      return;
+    }
+
+    if (groups.length === 0) return;
+
+    const currentGroup = groups[selectedGroupIndex];
+    const nodes = currentGroup.all;
+
+    if (key.tab) {
+      setActiveTab(prev => prev === 'groups' ? 'nodes' : 'groups');
+      return;
+    }
+
+    if (activeTab === 'groups') {
+      if (key.upArrow) {
+        setSelectedGroupIndex(prev => Math.max(0, prev - 1));
+        setSelectedNodeIndex(0); // Reset node selection when group changes
+      }
+      if (key.downArrow) {
+        setSelectedGroupIndex(prev => Math.min(groups.length - 1, prev + 1));
+        setSelectedNodeIndex(0);
+      }
+      if (key.rightArrow || key.return) {
+        setActiveTab('nodes');
+      }
+    } else {
+      // Nodes tab
+      if (key.upArrow) {
+        setSelectedNodeIndex(prev => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        setSelectedNodeIndex(prev => Math.min(nodes.length - 1, prev + 1));
+      }
+      if (key.leftArrow) {
+        setActiveTab('groups');
+      }
+      if (key.return) {
+        const nodeToSelect = nodes[selectedNodeIndex];
+        setMessage(`Switching ${currentGroup.name} to ${nodeToSelect}...`);
+        try {
+          await ClashAPI.switchProxy(currentGroup.name, nodeToSelect);
+          setMessage(`Switched to ${nodeToSelect}`);
+          await refreshProxies();
+        } catch (e: any) {
+          setMessage(`Error: ${e.message}`);
+        }
+      }
+    }
+  });
+
+  if (!status) return <Text>Loading...</Text>;
+  if (!status.running) return <Text color="red">Otter Core is not running. Run 'ot up' first.</Text>;
+  if (groups.length === 0) return <Text>Loading proxies...</Text>;
+
+  const currentGroup = groups[selectedGroupIndex];
+  const nodes = currentGroup.all;
+
+  // Scroll logic for nodes
+  const visibleNodes = 15;
+  let startNode = 0;
+  if (selectedNodeIndex > visibleNodes / 2) {
+    startNode = Math.min(selectedNodeIndex - Math.floor(visibleNodes / 2), nodes.length - visibleNodes);
+  }
+  startNode = Math.max(0, startNode);
+  const endNode = Math.min(startNode + visibleNodes, nodes.length);
+  const visibleNodeList = nodes.slice(startNode, endNode);
+
+  return (
+    <Box flexDirection="column" padding={1} height={25}>
+      {/* Header */}
+      <Box borderStyle="round" borderColor="cyan" flexDirection="row" justifyContent="space-between" paddingX={1}>
+        <Text color="cyan" bold>🦦 Otter TUI</Text>
+        <Box>
+          <Text>SysProxy: <Text color={systemProxyEnabled ? 'green' : 'red'}>{systemProxyEnabled ? 'ON' : 'OFF'}</Text> | </Text>
+          <Text>Mode: <Text color="magenta">{mode}</Text> | </Text>
+          <Text>Ver: <Text color="green">{status.version}</Text> | </Text>
+          <Text>Mem: <Text color="yellow">{formatSize(status.memory || 0)}</Text> | </Text>
+          <Text>PID: {status.pid}</Text>
+        </Box>
+      </Box>
+
+      {/* Main Content */}
+      <Box flexDirection="row" flexGrow={1}>
+
+        {/* Left Panel: Groups */}
+        <Box flexDirection="column" width="30%" borderStyle="single" borderColor={activeTab === 'groups' ? 'green' : 'gray'} paddingX={1}>
+          <Box marginBottom={1}>
+            <Text bold underline>Proxy Groups</Text>
+          </Box>
+          {groups.map((g, idx) => {
+            const isSelected = idx === selectedGroupIndex;
+            return (
+              <Box key={g.name}>
+                <Text color={isSelected ? 'green' : 'white'} bold={isSelected}>
+                  {isSelected ? '› ' : '  '}{g.name}
+                </Text>
+              </Box>
+            );
+          })}
+        </Box>
+
+        {/* Right Panel: Nodes */}
+        <Box flexDirection="column" width="70%" borderStyle="single" borderColor={activeTab === 'nodes' ? 'green' : 'gray'} paddingX={1}>
+          <Box flexDirection="row" justifyContent="space-between" marginBottom={1}>
+            <Text bold underline>Nodes in [{currentGroup.name}]</Text>
+            <Text color="gray">{selectedNodeIndex + 1}/{nodes.length}</Text>
+          </Box>
+
+          {visibleNodeList.map((node: string, idx: number) => {
+            const realIndex = startNode + idx;
+            const isFocused = realIndex === selectedNodeIndex;
+            const isActive = currentGroup.now === node;
+
+            return (
+              <Box key={node} flexDirection="row">
+                <Text color={isFocused ? 'cyan' : 'white'}>
+                  {isFocused ? '› ' : '  '}
+                </Text>
+                <Text color={isActive ? 'green' : (isFocused ? 'cyan' : 'white')}>
+                  {isActive ? '● ' : '  '}
+                  {node}
+                </Text>
+              </Box>
+            );
+          })}
+          {nodes.length > visibleNodes && (
+            <Box marginTop={1}>
+              <Text color="gray">... {nodes.length - endNode} more ...</Text>
+            </Box>
+          )}
+        </Box>
+      </Box>
+
+      {/* 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>
+      </Box>
+    </Box>
+  );
+};
+
+export const ui = async () => {
+  const { waitUntilExit } = render(<TuiApp />);
+  await waitUntilExit();
+};

package/src/utils/api.ts

@@ -0,0 +1,107 @@
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import { CONFIG_FILE } from './paths';
+
+interface Config {
+  'external-controller'?: string;
+  secret?: string;
+  'mixed-port'?: number;
+  port?: number;
+  'socks-port'?: number;
+}
+
+export class ClashAPI {
+  private static async getConfig(): Promise<Config> {
+    if (!await fs.pathExists(CONFIG_FILE)) {
+      throw new Error('Config file not found');
+    }
+    const content = await fs.readFile(CONFIG_FILE, 'utf-8');
+    return yaml.load(content) as Config;
+  }
+
+  private static async getBaseUrl(): Promise<string> {
+    const config = await this.getConfig();
+    const controller = config['external-controller'] || '127.0.0.1:9090';
+    return `http://${controller}`;
+  }
+
+  private static async getHeaders(): Promise<Record<string, string>> {
+    const config = await this.getConfig();
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (config.secret) {
+      headers['Authorization'] = `Bearer ${config.secret}`;
+    }
+    return headers;
+  }
+
+  static async getProxies(): Promise<any> {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    try {
+      const res = await fetch(`${baseUrl}/proxies`, { headers });
+      if (!res.ok) throw new Error(`API Error: ${res.statusText}`);
+      return await res.json();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static async switchProxy(groupName: string, nodeName: string) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const res = await fetch(`${baseUrl}/proxies/${encodeURIComponent(groupName)}`, {
+      method: 'PUT',
+      headers,
+      body: JSON.stringify({ name: nodeName })
+    });
+    if (!res.ok) throw new Error(`Failed to switch proxy: ${res.statusText}`);
+  }
+
+  static async getDelay(nodeName: string) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const url = `${baseUrl}/proxies/${encodeURIComponent(nodeName)}/delay?timeout=5000&url=http://www.gstatic.com/generate_204`;
+    const res = await fetch(url, { headers });
+    if (!res.ok) throw new Error(`Failed to test latency: ${res.statusText}`);
+    return await res.json();
+  }
+
+  static async getProxyPort(): Promise<{ http: number, socks: number, mixed: number }> {
+    const config = await this.getConfig();
+    return {
+      http: config.port || 0,
+      socks: config['socks-port'] || 0,
+      mixed: config['mixed-port'] || 0
+    };
+  }
+
+  static async getConfigs(): Promise<any> {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    try {
+      const res = await fetch(`${baseUrl}/configs`, { headers });
+      if (!res.ok) throw new Error(`API Error: ${res.statusText}`);
+      return await res.json();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static async updateConfig(config: any) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const res = await fetch(`${baseUrl}/configs`, {
+      method: 'PATCH',
+      headers,
+      body: JSON.stringify(config)
+    });
+    if (!res.ok) throw new Error(`Failed to update config: ${res.statusText}`);
+  }
+
+  static async getTrafficUrl(): Promise<string> {
+    const baseUrl = await this.getBaseUrl();
+    return baseUrl.replace('http://', 'ws://') + '/traffic';
+  }
+}

package/src/utils/core.ts

@@ -0,0 +1,153 @@
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import { BIN_PATH, CONFIG_FILE, HOME_DIR, LOG_FILE, PID_FILE } from './paths';
+import psList from 'ps-list';
+
+const execAsync = promisify(exec);
+
+export class CoreManager {
+  static async init() {
+    await fs.ensureDir(HOME_DIR);
+  }
+
+  static async isRunning(): Promise<boolean> {
+    if (!await fs.pathExists(PID_FILE)) {
+      return false;
+    }
+    const pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'), 10);
+    if (isNaN(pid)) return false;
+
+    const list = await psList();
+    return list.some(p => p.pid === pid);
+  }
+
+  static async start() {
+    await this.init();
+
+    if (await this.isRunning()) {
+      console.log('Otter (Mihomo) is already running.');
+      return;
+    }
+
+    if (!await fs.pathExists(BIN_PATH)) {
+      throw new Error(`Mihomo binary not found at ${BIN_PATH}`);
+    }
+
+    // Ensure executable permission
+    await fs.chmod(BIN_PATH, 0o755);
+
+    // Check for quarantine on macOS
+    if (process.platform === 'darwin') {
+      try {
+        await execAsync(`xattr -p com.apple.quarantine "${BIN_PATH}"`);
+        // If command succeeds, the attribute exists
+        console.error('\n\x1b[31mError: The Mihomo binary is quarantined by macOS.\x1b[0m');
+        console.error('You need to run the following command to allow it to run:');
+        console.error(`\n  \x1b[33msudo xattr -d com.apple.quarantine "${BIN_PATH}"\x1b[0m\n`);
+        throw new Error('Binary is quarantined');
+      } catch (e: any) {
+        // If command fails (exit code 1), the attribute does not exist, which is good.
+        // If it's another error, we ignore it for now.
+        if (e.message === 'Binary is quarantined') throw e;
+      }
+    }
+
+    // Check config
+    if (!await fs.pathExists(CONFIG_FILE)) {
+      console.log(`Config file not found. Creating default at ${CONFIG_FILE}...`);
+      const defaultConfig = `
+mixed-port: 7890
+allow-lan: false
+mode: rule
+log-level: info
+external-controller: 127.0.0.1:9090
+`;
+      await fs.writeFile(CONFIG_FILE, defaultConfig.trim());
+    } else {
+      // Check if external-controller is enabled in existing config
+      const configContent = await fs.readFile(CONFIG_FILE, 'utf-8');
+      if (!configContent.includes('external-controller')) {
+        console.warn(`Warning: 'external-controller' not found in ${CONFIG_FILE}. API features might not work.`);
+        console.warn(`Please add 'external-controller: 127.0.0.1:9090' to your config.`);
+      }
+    }
+
+    // Ensure log file exists
+    await fs.ensureFile(LOG_FILE);
+    const logFd = await fs.open(LOG_FILE, 'a');
+
+    console.log(`Starting Mihomo from ${BIN_PATH}...`);
+
+    const child = spawn(BIN_PATH, ['-d', HOME_DIR], {
+      detached: true,
+      stdio: ['ignore', logFd, logFd]
+    });
+
+    if (child.pid) {
+      await fs.writeFile(PID_FILE, child.pid.toString());
+      child.unref();
+      console.log(`Mihomo started with PID ${child.pid}`);
+    } else {
+      throw new Error('Failed to start Mihomo process');
+    }
+  }
+
+  static async stop() {
+    if (!await this.isRunning()) {
+      console.log('Otter is not running.');
+      return;
+    }
+    const pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'), 10);
+    try {
+      process.kill(pid);
+      console.log(`Stopped process ${pid}`);
+    } catch (e) {
+      console.error(`Failed to stop process ${pid}:`, e);
+    }
+    await fs.remove(PID_FILE);
+  }
+
+  static async getStatus() {
+    const running = await this.isRunning();
+    if (!running) {
+      return { running: false };
+    }
+
+    const pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'), 10);
+
+    // Try to fetch version from API
+    // Default external controller is 127.0.0.1:9090
+    // We should parse config.yaml to find the real port, but for now assume default
+    let version = 'Unknown';
+    let memory = 0;
+
+    try {
+      // Using Bun's built-in fetch
+      const res = await fetch('http://127.0.0.1:9090/version');
+      if (res.ok) {
+        const data = await res.json() as any;
+        version = data.version || 'Unknown';
+      }
+    } catch (e) {
+      version = 'API Unreachable';
+    }
+
+    // Get memory usage (RSS in Bytes)
+    try {
+      const { stdout } = await execAsync(`ps -o rss= -p ${pid}`);
+      if (stdout) {
+        memory = parseInt(stdout.trim(), 10) * 1024; // KB to Bytes
+      }
+    } catch (e) {
+      // Fallback to 0
+    }
+
+    return {
+      running: true,
+      pid,
+      version,
+      memory
+    };
+  }
+}