@meanc/otter 0.0.1

package/src/utils/parser.ts

@@ -0,0 +1,193 @@
+import yaml from 'js-yaml';
+
+interface Proxy {
+  name: string;
+  type: string;
+  server: string;
+  port: number;
+  [key: string]: any;
+}
+
+export class ConfigParser {
+  static parse(content: string): string {
+    // 1. Check if it's already YAML
+    try {
+      const parsed = yaml.load(content) as any;
+      if (parsed && (parsed.proxies || parsed['proxy-groups'])) {
+        return content;
+      }
+    } catch (e) { }
+
+    // 2. Try Base64 decode
+    let decoded = content;
+    try {
+      const clean = content.trim();
+      // Simple check if it looks like base64 (no spaces, valid chars)
+      if (!clean.includes(' ') && /^[a-zA-Z0-9+/=]+$/.test(clean)) {
+        decoded = atob(clean);
+      }
+    } catch (e) {
+      // If decode fails, continue with original content
+    }
+
+    const lines = decoded.split(/\r?\n/).filter(l => l.trim() !== '');
+    const proxies: Proxy[] = [];
+
+    for (const line of lines) {
+      const l = line.trim();
+      if (l.startsWith('vmess://')) {
+        const p = this.parseVmess(l);
+        if (p) proxies.push(p);
+      } else if (l.startsWith('ss://')) {
+        const p = this.parseSS(l);
+        if (p) proxies.push(p);
+      } else if (l.startsWith('trojan://')) {
+        const p = this.parseTrojan(l);
+        if (p) proxies.push(p);
+      }
+    }
+
+    if (proxies.length === 0) {
+      return content;
+    }
+
+    // Construct Clash Config
+    const config = {
+      port: 7890,
+      'socks-port': 7891,
+      'mixed-port': 7890,
+      'allow-lan': false,
+      mode: 'rule',
+      'log-level': 'info',
+      'external-controller': '127.0.0.1:9090',
+      proxies: proxies,
+      'proxy-groups': [
+        {
+          name: 'Proxy',
+          type: 'select',
+          proxies: ['Auto', ...proxies.map(p => p.name)]
+        },
+        {
+          name: 'Auto',
+          type: 'url-test',
+          url: 'http://www.gstatic.com/generate_204',
+          interval: 300,
+          proxies: proxies.map(p => p.name)
+        }
+      ],
+      rules: [
+        'MATCH,Proxy'
+      ]
+    };
+
+    return yaml.dump(config);
+  }
+
+  private static parseVmess(url: string): Proxy | null {
+    try {
+      const b64 = url.slice(8);
+      const jsonStr = atob(b64);
+      const config = JSON.parse(jsonStr);
+
+      return {
+        name: config.ps || 'vmess',
+        type: 'vmess',
+        server: config.add,
+        port: parseInt(config.port),
+        uuid: config.id,
+        alterId: parseInt(config.aid || '0'),
+        cipher: 'auto',
+        tls: config.tls === 'tls',
+        servername: config.host || '',
+        network: config.net || 'tcp',
+        'ws-opts': config.net === 'ws' ? {
+          path: config.path || '/',
+          headers: {
+            Host: config.host || ''
+          }
+        } : undefined
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private static parseSS(url: string): Proxy | null {
+    try {
+      let raw = url.slice(5);
+      let name = 'ss';
+      const hashIndex = raw.indexOf('#');
+      if (hashIndex !== -1) {
+        name = decodeURIComponent(raw.substring(hashIndex + 1));
+        raw = raw.substring(0, hashIndex);
+      }
+
+      let method, password, server, port;
+
+      if (raw.includes('@')) {
+        // SIP002: userinfo@host:port
+        const atIndex = raw.lastIndexOf('@');
+        const userInfoB64 = raw.substring(0, atIndex);
+        const hostPort = raw.substring(atIndex + 1);
+
+        // userInfoB64 decodes to method:password
+        const userInfo = atob(userInfoB64);
+        [method, password] = userInfo.split(':');
+        [server, port] = hostPort.split(':');
+      } else {
+        // Legacy: base64(method:password@host:port)
+        const decoded = atob(raw);
+        // method:password@host:port
+        const atIndex = decoded.lastIndexOf('@');
+        const userInfo = decoded.substring(0, atIndex);
+        const hostPort = decoded.substring(atIndex + 1);
+
+        [method, password] = userInfo.split(':');
+        [server, port] = hostPort.split(':');
+      }
+
+      if (!server || !port) return null;
+
+      return {
+        name,
+        type: 'ss',
+        server,
+        port: parseInt(port),
+        cipher: method,
+        password
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private static parseTrojan(url: string): Proxy | null {
+    try {
+      let raw = url.slice(9);
+      let name = 'trojan';
+      const hashIndex = raw.indexOf('#');
+      if (hashIndex !== -1) {
+        name = decodeURIComponent(raw.substring(hashIndex + 1));
+        raw = raw.substring(0, hashIndex);
+      }
+
+      const atIndex = raw.indexOf('@');
+      const userInfo = raw.substring(0, atIndex);
+      const hostPort = raw.substring(atIndex + 1);
+      const [server, portStr] = hostPort.split(':');
+
+      if (!server || !portStr) return null;
+
+      return {
+        name,
+        type: 'trojan',
+        server,
+        port: parseInt(portStr),
+        password: userInfo,
+        udp: true
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/src/utils/paths.ts

@@ -0,0 +1,10 @@
+import path from 'path';
+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 LOG_FILE = path.join(HOME_DIR, 'otter.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');

package/src/utils/subscription.ts

@@ -0,0 +1,169 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { SUBSCRIPTIONS_FILE, PROFILES_DIR, CONFIG_FILE } from './paths';
+import { CoreManager } from './core';
+import { ConfigParser } from './parser';
+import chalk from 'chalk';
+
+export interface Subscription {
+  name: string;
+  url: string;
+  updatedAt: string;
+}
+
+export interface SubscriptionData {
+  active: string | null;
+  subscriptions: Subscription[];
+}
+
+export class SubscriptionManager {
+  static async init() {
+    await fs.ensureDir(PROFILES_DIR);
+    if (!await fs.pathExists(SUBSCRIPTIONS_FILE)) {
+      const initialData: SubscriptionData = {
+        active: null,
+        subscriptions: []
+      };
+      await fs.writeJson(SUBSCRIPTIONS_FILE, initialData, { spaces: 2 });
+    }
+  }
+
+  static async getData(): Promise<SubscriptionData> {
+    await this.init();
+    return await fs.readJson(SUBSCRIPTIONS_FILE);
+  }
+
+  static async saveData(data: SubscriptionData) {
+    await fs.writeJson(SUBSCRIPTIONS_FILE, data, { spaces: 2 });
+  }
+
+  static async add(name: string, url: string) {
+    const data = await this.getData();
+    if (data.subscriptions.find(s => s.name === name)) {
+      throw new Error(`Subscription '${name}' already exists.`);
+    }
+
+    console.log(chalk.blue(`Fetching configuration from ${url}...`));
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch: ${response.statusText}`);
+    }
+    let configContent = await response.text();
+
+    // Try to parse/convert if it's not standard Clash config
+    configContent = ConfigParser.parse(configContent);
+
+    // Basic validation
+    if (!configContent.includes('proxies:') && !configContent.includes('proxy-groups:')) {
+      console.warn(chalk.yellow('Warning: The downloaded content does not look like a standard Clash config.'));
+    }
+
+    const profilePath = path.join(PROFILES_DIR, `${name}.yaml`);
+    await fs.writeFile(profilePath, configContent);
+
+    data.subscriptions.push({
+      name,
+      url,
+      updatedAt: new Date().toISOString()
+    });
+
+    // If it's the first subscription, make it active
+    if (!data.active) {
+      data.active = name;
+      await fs.copy(profilePath, CONFIG_FILE);
+    }
+
+    await this.saveData(data);
+    console.log(chalk.green(`Subscription '${name}' added successfully.`));
+  }
+
+  static async remove(name: string) {
+    const data = await this.getData();
+    const index = data.subscriptions.findIndex(s => s.name === name);
+    if (index === -1) {
+      throw new Error(`Subscription '${name}' not found.`);
+    }
+
+    data.subscriptions.splice(index, 1);
+    const profilePath = path.join(PROFILES_DIR, `${name}.yaml`);
+    await fs.remove(profilePath);
+
+    if (data.active === name) {
+      data.active = null;
+      console.warn(chalk.yellow(`Active subscription '${name}' removed. Please select another subscription.`));
+    }
+
+    await this.saveData(data);
+    console.log(chalk.green(`Subscription '${name}' removed.`));
+  }
+
+  static async update(name: string) {
+    const data = await this.getData();
+    const sub = data.subscriptions.find(s => s.name === name);
+    if (!sub) {
+      throw new Error(`Subscription '${name}' not found.`);
+    }
+
+    console.log(chalk.blue(`Updating subscription '${name}' from ${sub.url}...`));
+    const response = await fetch(sub.url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch: ${response.statusText}`);
+    }
+    let configContent = await response.text();
+
+    // Try to parse/convert
+    configContent = ConfigParser.parse(configContent);
+    sub.updatedAt = new Date().toISOString();
+    await this.saveData(data);
+    console.log(chalk.green(`Subscription '${name}' updated.`));
+
+    if (data.active === name) {
+      await this.apply(name);
+    }
+  }
+
+  static async use(name: string) {
+    const data = await this.getData();
+    const sub = data.subscriptions.find(s => s.name === name);
+    if (!sub) {
+      throw new Error(`Subscription '${name}' not found.`);
+    }
+
+    await this.apply(name);
+
+    data.active = name;
+    await this.saveData(data);
+    console.log(chalk.green(`Switched to subscription '${name}'.`));
+  }
+
+  static async apply(name: string) {
+    const profilePath = path.join(PROFILES_DIR, `${name}.yaml`);
+    if (!await fs.pathExists(profilePath)) {
+      throw new Error(`Profile file for '${name}' not found.`);
+    }
+
+    await fs.copy(profilePath, CONFIG_FILE);
+
+    if (await CoreManager.isRunning()) {
+      console.log(chalk.blue('Restarting core to apply changes...'));
+      await CoreManager.stop();
+      await CoreManager.start();
+    }
+  }
+
+  static async list() {
+    const data = await this.getData();
+    if (data.subscriptions.length === 0) {
+      console.log('No subscriptions found.');
+      return;
+    }
+
+    console.log(chalk.bold('Subscriptions:'));
+    data.subscriptions.forEach(sub => {
+      const isActive = data.active === sub.name;
+      const prefix = isActive ? chalk.green('* ') : '  ';
+      const name = isActive ? chalk.green(sub.name) : sub.name;
+      console.log(`${prefix}${name} (${sub.url}) - Updated: ${sub.updatedAt}`);
+    });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}