@meanc/otter 0.0.1

package/src/commands/core.tsx

@@ -0,0 +1,181 @@
+import React, { useState, useEffect } from 'react';
+import { render, Text, Box, useApp, useInput } from 'ink';
+import { CoreManager } from '../utils/core';
+import { ClashAPI } from '../utils/api';
+import { SubscriptionManager } from '../utils/subscription';
+import { LOG_FILE } from '../utils/paths';
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+
+const formatSpeed = (bytes: number) => {
+  if (bytes === 0) return '0 B/s';
+  const k = 1024;
+  const sizes = ['B/s', 'KB/s', 'MB/s', 'GB/s', 'TB/s'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+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];
+};
+
+export const start = async () => {
+  try {
+    await CoreManager.start();
+  } catch (error: any) {
+    console.error('Error starting core:', error.message);
+  }
+};
+
+export const stop = async () => {
+  try {
+    await CoreManager.stop();
+  } catch (error: any) {
+    console.error('Error stopping core:', error.message);
+  }
+};
+
+export const status = async () => {
+  const StatusApp = () => {
+    const { exit } = useApp();
+    const [coreStatus, setCoreStatus] = useState<any>(null);
+    const [traffic, setTraffic] = useState({ up: 0, down: 0 });
+    const [subInfo, setSubInfo] = useState<{ active: string | null, count: number } | null>(null);
+    const [proxyCount, setProxyCount] = useState<number>(0);
+
+    useInput((input, key) => {
+      if (key.escape || input === 'q' || (key.ctrl && input === 'c')) {
+        exit();
+      }
+    });
+
+    useEffect(() => {
+      let ws: WebSocket | null = null;
+
+      const fetchData = async () => {
+        const s = await CoreManager.getStatus();
+        setCoreStatus(s);
+
+        if (s.running) {
+          // Subs
+          try {
+            const subs = await SubscriptionManager.getData();
+            setSubInfo({ active: subs.active, count: subs.subscriptions.length });
+          } catch (e) { }
+
+          // Proxies
+          try {
+            const p = await ClashAPI.getProxies();
+            if (p && p.proxies) {
+              setProxyCount(Object.keys(p.proxies).length);
+            }
+          } catch (e) { }
+
+          // Traffic WS
+          try {
+            const wsUrl = await ClashAPI.getTrafficUrl();
+            ws = new WebSocket(wsUrl);
+            ws.onmessage = (event) => {
+              const data = JSON.parse(event.data as string);
+              setTraffic(data);
+            };
+          } catch (e) { }
+        }
+      };
+
+      fetchData();
+
+      // Poll core status
+      const interval = setInterval(async () => {
+        const s = await CoreManager.getStatus();
+        setCoreStatus(s);
+      }, 2000);
+
+      return () => {
+        clearInterval(interval);
+        if (ws) ws.close();
+      };
+    }, []);
+
+    if (!coreStatus) return <Text>Loading status...</Text>;
+
+    if (!coreStatus.running) {
+      return (
+        <Box borderStyle="round" borderColor="red" 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>
+
+        <Box marginTop={1} flexDirection="column">
+          <Box>
+            <Box width={12}><Text>PID:</Text></Box>
+            <Text color="blue">{coreStatus.pid}</Text>
+          </Box>
+          <Box>
+            <Box width={12}><Text>Version:</Text></Box>
+            <Text color="yellow">{coreStatus.version}</Text>
+          </Box>
+          <Box>
+            <Box width={12}><Text>Memory:</Text></Box>
+            <Text color="cyan">{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>
+          </Box>
+          <Box>
+            <Box width={12}><Text>Proxies:</Text></Box>
+            <Text>{proxyCount}</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>
+          </Box>
+        </Box>
+      </Box>
+    );
+  };
+
+  const { waitUntilExit } = render(<StatusApp />);
+  await waitUntilExit();
+};
+export const log = async () => {
+  if (!await fs.pathExists(LOG_FILE)) {
+    console.log('No log file found.');
+    return;
+  }
+  console.log(`Tailing logs from ${LOG_FILE}...`);
+  const tail = spawn('tail', ['-f', LOG_FILE], { stdio: 'inherit' });
+
+  // Handle exit
+  process.on('SIGINT', () => {
+    tail.kill();
+    process.exit();
+  });
+};

package/src/commands/proxy.ts

@@ -0,0 +1,203 @@
+import { ClashAPI } from '../utils/api';
+import chalk from 'chalk';
+import { renderLS } from './ui';
+
+export const list = async () => {
+  await renderLS();
+};
+
+export const use = async (nodeName?: string, options?: any) => {
+  const data = await ClashAPI.getProxies();
+  if (!data || !data.proxies) {
+    console.error(chalk.red('Failed to fetch proxies.'));
+    return;
+  }
+
+  const proxies = data.proxies;
+  const groups = Object.values(proxies).filter((p: any) => p.type === 'Selector');
+
+  // Helper to switch by index in a specific group
+  const switchByIndex = async (groupName: string, index: number) => {
+    const group = groups.find((g: any) => g.name === groupName);
+    if (!group) {
+      console.error(chalk.red(`Group '${groupName}' not found.`));
+      return true;
+    }
+    if (index > 0 && index <= (group as any).all.length) {
+      const node = (group as any).all[index - 1];
+      try {
+        await ClashAPI.switchProxy(group.name, node);
+        console.log(chalk.green(`Switched [${group.name}] to '${node}'`));
+      } catch (e: any) {
+        console.error(chalk.red(e.message));
+      }
+    } else {
+      console.error(chalk.red(`Index ${index} out of range for ${groupName}.`));
+    }
+    return true;
+  };
+
+  // Handle -p (Proxy)
+  if (options?.proxy || options?.p) {
+    const idx = parseInt(options.proxy || options.p);
+    if (await switchByIndex('Proxy', idx)) return;
+  }
+
+  // Handle -g (GLOBAL)
+  if (options?.global || options?.g) {
+    const idx = parseInt(options.global || options.g);
+    if (await switchByIndex('GLOBAL', idx)) return;
+  }
+
+  // Handle bare number -> Default to Proxy group
+  if (nodeName && /^\d+$/.test(nodeName)) {
+    const idx = parseInt(nodeName);
+    if (await switchByIndex('Proxy', idx)) return;
+  }
+
+  if (!nodeName) {
+    console.error(chalk.red('Please specify a node name or index.'));
+    return;
+  }
+
+  // Find target node (fuzzy match)
+  // We need to find which group contains this node, or if the user wants to switch a specific group
+  // Usually 'use' implies switching the main selector (often 'Proxy' or 'GLOBAL' or the first one)
+  // Or we can search all groups and switch where possible.
+
+  // Strategy:
+  // 1. If nodeName matches a group name, maybe they want to select that group? (Not common in 'use node')
+  // 2. Search for nodeName in all groups.
+
+  let targetNode = nodeName;
+  let targetGroup: any = null;
+
+  // Simple fuzzy search helper
+  const findNode = (search: string, candidates: string[]) => {
+    const lower = search.toLowerCase();
+    return candidates.find(c => c.toLowerCase().includes(lower));
+  };
+
+  // Try to find a group that has this node
+  // We prioritize the "Proxy" or "GLOBAL" group if it exists
+  const priorityGroups = ['Proxy', 'GLOBAL', '节点选择'];
+
+  for (const gName of priorityGroups) {
+    const g = groups.find((x: any) => x.name === gName);
+    if (g) {
+      const match = findNode(nodeName, g.all);
+      if (match) {
+        targetGroup = g;
+        targetNode = match;
+        break;
+      }
+    }
+  }
+
+  // If not found in priority, search all
+  if (!targetGroup) {
+    for (const g of groups) {
+      const match = findNode(nodeName, (g as any).all);
+      if (match) {
+        targetGroup = g;
+        targetNode = match;
+        break;
+      }
+    }
+  }
+
+  if (!targetGroup) {
+    console.error(chalk.red(`Node '${nodeName}' not found in any selector group.`));
+    return;
+  }
+
+  try {
+    await ClashAPI.switchProxy(targetGroup.name, targetNode);
+    console.log(chalk.green(`Switched [${targetGroup.name}] to '${targetNode}'`));
+  } catch (e: any) {
+    console.error(chalk.red(e.message));
+  }
+};
+
+export const test = async () => {
+  const data = await ClashAPI.getProxies();
+  if (!data) return;
+
+  // Find current node of the main selector
+  const proxies = data.proxies;
+  const groups = Object.values(proxies).filter((p: any) => p.type === 'Selector');
+
+  // Heuristic: First group is usually the main one
+  const mainGroup: any = groups.find((g: any) => ['Proxy', 'GLOBAL'].includes(g.name)) || groups[0];
+
+  if (!mainGroup) {
+    console.log('No selector group found.');
+    return;
+  }
+
+  const currentNode = mainGroup.now;
+  console.log(`Testing latency for ${chalk.cyan(currentNode)}...`);
+
+  try {
+    const res = await ClashAPI.getDelay(currentNode);
+    console.log(chalk.green(`Latency: ${res.delay}ms`));
+  } catch (e: any) {
+    console.error(chalk.red('Timeout or Error'));
+  }
+};
+
+export const best = async () => {
+  console.log(chalk.blue('Testing all nodes to find the best one...'));
+
+  const data = await ClashAPI.getProxies();
+  if (!data || !data.proxies) {
+    console.error(chalk.red('Failed to fetch proxies. Is Otter running?'));
+    return;
+  }
+
+  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];
+
+  if (!mainGroup) {
+    console.error(chalk.red('Could not determine main proxy group.'));
+    return;
+  }
+
+  console.log(chalk.gray(`Testing group: ${mainGroup.name} (${mainGroup.all.length} nodes)`));
+
+  const candidates: string[] = mainGroup.all;
+  let bestNode = '';
+  let minDelay = Infinity;
+
+  // Limit concurrency
+  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) {
+    console.log(chalk.green(`Best node found: ${bestNode} (${minDelay}ms)`));
+    await ClashAPI.switchProxy(mainGroup.name, bestNode);
+    console.log(`Switched to ${bestNode}`);
+  } else {
+    console.error(chalk.red('No reachable nodes found.'));
+  }
+};

package/src/commands/subscribe.ts

@@ -0,0 +1,43 @@
+import { SubscriptionManager } from '../utils/subscription';
+import chalk from 'chalk';
+
+export const add = async (url: string, name?: string) => {
+  try {
+    const subName = name || new URL(url).hostname;
+    await SubscriptionManager.add(subName, url);
+  } catch (error: any) {
+    console.error(chalk.red(`Error adding subscription: ${error.message}`));
+  }
+};
+
+export const remove = async (name: string) => {
+  try {
+    await SubscriptionManager.remove(name);
+  } catch (error: any) {
+    console.error(chalk.red(`Error removing subscription: ${error.message}`));
+  }
+};
+
+export const update = async (name: string) => {
+  try {
+    await SubscriptionManager.update(name);
+  } catch (error: any) {
+    console.error(chalk.red(`Error updating subscription: ${error.message}`));
+  }
+};
+
+export const use = async (name: string) => {
+  try {
+    await SubscriptionManager.use(name);
+  } catch (error: any) {
+    console.error(chalk.red(`Error switching subscription: ${error.message}`));
+  }
+};
+
+export const list = async () => {
+  try {
+    await SubscriptionManager.list();
+  } catch (error: any) {
+    console.error(chalk.red(`Error listing subscriptions: ${error.message}`));
+  }
+};

package/src/commands/system.ts

@@ -0,0 +1,152 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import { ClashAPI } from '../utils/api';
+
+const execAsync = promisify(exec);
+
+// Helper to detect active network service on macOS
+const getActiveService = async () => {
+  try {
+    // This is a heuristic. We look for the service associated with the default route interface.
+    // 1. Get default route interface
+    const { stdout: routeOut } = await execAsync('route get default | grep interface');
+    const interfaceName = routeOut.split(':')[1].trim();
+
+    // 2. Get service name for that interface
+    const { stdout: servicesOut } = await execAsync('networksetup -listallhardwareports');
+
+    // Parse output to find the service name for the interface
+    // Output format:
+    // Hardware Port: Wi-Fi
+    // Device: en0
+    // Ethernet Address: ...
+
+    const lines = servicesOut.split('\n');
+    let currentService = '';
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith('Hardware Port:')) {
+        currentService = line.split(':')[1].trim();
+      }
+      if (line.includes(`Device: ${interfaceName}`)) {
+        return currentService;
+      }
+    }
+    return 'Wi-Fi'; // Fallback
+  } catch (e) {
+    return 'Wi-Fi'; // Fallback
+  }
+};
+
+export const getSystemProxyStatus = async () => {
+  try {
+    const service = await getActiveService();
+    const { stdout } = await execAsync(`networksetup -getwebproxy "${service}"`);
+    return stdout.includes('Enabled: Yes');
+  } catch (e) {
+    return false;
+  }
+};
+
+export const on = async (optionsOrSilent?: any) => {
+  const silent = typeof optionsOrSilent === 'boolean' ? optionsOrSilent : false;
+  try {
+    const service = await getActiveService();
+    const ports = await ClashAPI.getProxyPort();
+
+    if (ports.mixed === 0 && ports.http === 0 && ports.socks === 0) {
+      if (!silent) console.error(chalk.red('Could not determine proxy ports from config.'));
+      return;
+    }
+
+    const httpPort = ports.http || ports.mixed;
+    const socksPort = ports.socks || ports.mixed;
+
+    if (!silent) console.log(chalk.blue(`Enabling proxy for service: ${service}`));
+
+    if (httpPort) {
+      await execAsync(`networksetup -setwebproxy "${service}" 127.0.0.1 ${httpPort}`);
+      await execAsync(`networksetup -setsecurewebproxy "${service}" 127.0.0.1 ${httpPort}`);
+      if (!silent) console.log(chalk.green(`HTTP/HTTPS Proxy set to 127.0.0.1:${httpPort}`));
+    }
+
+    if (socksPort) {
+      await execAsync(`networksetup -setsocksfirewallproxy "${service}" 127.0.0.1 ${socksPort}`);
+      if (!silent) console.log(chalk.green(`SOCKS Proxy set to 127.0.0.1:${socksPort}`));
+    }
+
+    // Turn them on
+    if (httpPort) {
+      await execAsync(`networksetup -setwebproxystate "${service}" on`);
+      await execAsync(`networksetup -setsecurewebproxystate "${service}" on`);
+    }
+    if (socksPort) {
+      await execAsync(`networksetup -setsocksfirewallproxystate "${service}" on`);
+    }
+
+  } catch (error: any) {
+    if (!silent) {
+      console.error(chalk.red(`Error enabling system proxy: ${error.message}`));
+      console.error(chalk.yellow('Note: This command requires sudo privileges if not prompted.'));
+    }
+  }
+};
+
+export const off = async (optionsOrSilent?: any) => {
+  const silent = typeof optionsOrSilent === 'boolean' ? optionsOrSilent : false;
+  try {
+    const service = await getActiveService();
+    if (!silent) console.log(chalk.blue(`Disabling proxy for service: ${service}`));
+
+    await execAsync(`networksetup -setwebproxystate "${service}" off`);
+    await execAsync(`networksetup -setsecurewebproxystate "${service}" off`);
+    await execAsync(`networksetup -setsocksfirewallproxystate "${service}" off`);
+
+    if (!silent) console.log(chalk.green('System proxy disabled.'));
+  } catch (error: any) {
+    if (!silent) console.error(chalk.red(`Error disabling system proxy: ${error.message}`));
+  }
+};
+
+export const shell = async () => {
+  const ports = await ClashAPI.getProxyPort();
+  const port = ports.http || ports.mixed || 7890;
+
+  console.log(chalk.yellow('Copy and run the following commands in your terminal:'));
+  console.log('');
+  console.log(`export http_proxy=http://127.0.0.1:${port}`);
+  console.log(`export https_proxy=http://127.0.0.1:${port}`);
+  console.log(`export all_proxy=socks5://127.0.0.1:${port}`);
+  console.log('');
+  console.log(chalk.gray('# To undo:'));
+  console.log('unset http_proxy https_proxy all_proxy');
+};
+
+export const mode = async (modeName?: string) => {
+  if (!modeName) {
+    const config = await ClashAPI.getConfigs();
+    if (config) {
+      console.log(`Current mode: ${chalk.green(config.mode)}`);
+    } else {
+      console.error(chalk.red('Failed to get config.'));
+    }
+    return;
+  }
+
+  const validModes = ['global', 'rule', 'direct'];
+  const m = modeName.toLowerCase();
+  if (!validModes.includes(m)) {
+    console.error(chalk.red(`Invalid mode: ${modeName}. Valid modes: ${validModes.join(', ')}`));
+    return;
+  }
+
+  // Capitalize first letter for API
+  const apiMode = m.charAt(0).toUpperCase() + m.slice(1);
+  try {
+    await ClashAPI.updateConfig({ mode: apiMode });
+    console.log(chalk.green(`Switched to ${apiMode} mode.`));
+  } catch (e: any) {
+    console.error(chalk.red(e.message));
+  }
+};