taphoaapi 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# prox-claude-installer
+
+CLI tool to install and configure Claude Code with custom proxy settings.
+
+## Installation
+
+```bash
+npm install -g prox-claude-installer
+```
+
+Or run directly with bunx/npx:
+
+```bash
+bunx prox-claude-installer
+# or
+npx prox-claude-installer
+```
+
+## Usage
+
+Simply run:
+
+```bash
+prox-claude-installer
+```
+
+The CLI will guide you through:
+1. Enter your Anthropic Auth Token
+2. Enter your proxy Base URL
+3. Select your operating system
+4. Choose default Claude model
+
+## Features
+
+- Interactive CLI with Vietnamese interface
+- Automatic Claude Code installation
+- Configuration management for Claude Code
+- Permanent environment variable setup
+- Support for Windows, macOS, and Linux
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Bun or npm (for running the installer)
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Entry Point for prox-claude-installer
+ * Main interactive CLI for setting up Claude Code with proxy
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { installClaude } from '../src/installer.js';
+import { updateConfig } from '../src/config.js';
+import { setEnvironmentVariable } from '../src/env.js';
+
+const QUESTIONS = [
+  {
+    type: 'input',
+    name: 'authToken',
+    message: '🔑 Nhập Auth Token của bạn:',
+    validate: (input) => {
+      if (!input || input.trim() === '') {
+        return 'Vui lòng nhập Auth Token!';
+      }
+      if (!input.startsWith('sk-')) {
+        return 'Token phải bắt đầu bằng sk-';
+      }
+      return true;
+    }
+  },
+  {
+    type: 'input',
+    name: 'baseUrl',
+    message: '🌐 Nhập Base URL (proxy):',
+    default: 'https://taphoaapi.info.vn/',
+    validate: (input) => {
+      if (!input || input.trim() === '') {
+        return 'Vui lòng nhập Base URL!';
+      }
+      try {
+        new URL(input);
+        return true;
+      } catch {
+        return 'URL không hợp lệ!';
+      }
+    }
+  },
+  {
+    type: 'list',
+    name: 'os',
+    message: '🖥️  Chọn hệ điều hành của bạn:',
+    choices: [
+      { name: 'Windows (PowerShell)', value: 'windows' },
+      { name: 'macOS (Zsh)', value: 'macos' },
+      { name: 'Linux (Bash)', value: 'linux' }
+    ]
+  },
+  {
+    type: 'list',
+    name: 'model',
+    message: '🤖 Chọn model Claude mặc định:',
+    choices: [
+      { name: 'Opus (cao cấp nhất)', value: 'opus' },
+      { name: 'Sonnet (cân bằng)', value: 'sonnet' },
+      { name: 'Haiku (nhanh nhất)', value: 'haiku' }
+    ],
+    default: 'sonnet'
+  }
+];
+
+async function main() {
+  // Banner
+  console.log(chalk.cyan(`
+╔═══════════════════════════════════════════╗
+║                                           ║
+║     🚀 TaphoaAPI Claude Setup             ║
+║                                           ║
+╚═══════════════════════════════════════════╝
+  `));
+
+  console.log(chalk.gray('   Đang khởi động installer...\n'));
+
+  try {
+    // Collect user inputs
+    const answers = await inquirer.prompt(QUESTIONS);
+
+    console.log(chalk.yellow('\n⚙️  Đang xử lý...\n'));
+
+    // Step 1: Install Claude Code
+    console.log(chalk.blue('📦 Đang cài đặt Claude Code...'));
+    await installClaude();
+    console.log(chalk.green('✅ Claude Code đã cài đặt thành công!'));
+
+    // Step 2: Update config
+    console.log(chalk.blue('\n⚙️  Đang cập nhật cấu hình...'));
+    await updateConfig(answers);
+    console.log(chalk.green('✅ Cấu hình đã được cập nhật!'));
+
+    // Step 3: Set environment variables
+    console.log(chalk.blue('\n🔧 Đang thiết lập biến môi trường...'));
+    await setEnvironmentVariable('ANTHROPIC_AUTH_TOKEN', answers.authToken, answers.os);
+    await setEnvironmentVariable('ANTHROPIC_BASE_URL', answers.baseUrl, answers.os);
+    console.log(chalk.green('✅ Thiết lập biến môi trường thành công!'));
+
+    // Success message
+    console.log(chalk.green(`
+
+╔═══════════════════════════════════════════╗
+║                                           ║
+║     ✨ Setup complete!                    ║
+║                                           ║
+║     Gõ "claude" để bắt đầu sử dụng       ║
+║                                           ║
+╚═══════════════════════════════════════════╝
+    `));
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ Lỗi:'), error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/index.js

@@ -0,0 +1,15 @@
+/**
+ * prox-claude-installer
+ * CLI tool to install and configure Claude Code with custom proxy settings
+ *
+ * @module prox-claude-installer
+ */
+
+// Export all modules
+export { installClaude, isClaudeInstalled, getClaudeVersion } from './src/installer.js';
+export { updateConfig, readCurrentConfig, getConfigValue } from './src/config.js';
+export { setEnvironmentVariable, getEnv, hasEnv } from './src/env.js';
+
+// Package info
+export const name = 'prox-claude-installer';
+export const version = '1.0.3';

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "taphoaapi",
+  "version": "1.0.0",
+  "description": "CLI tool to install and configure Claude Code with taphoaapi proxy",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "taphoaapi": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "ai",
+    "cli",
+    "installer",
+    "taphoaapi"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/taphoaapi"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/taphoaapi/issues"
+  }
+}

package/src/config.js

@@ -0,0 +1,131 @@
+/**
+ * Configuration Manager Module
+ * Handles reading and writing Claude Code settings
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+/**
+ * Get the Claude config directory path
+ * @returns {string}
+ */
+function getConfigDir() {
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.claude');
+}
+
+/**
+ * Get the Claude settings.json path
+ * @returns {string}
+ */
+function getConfigPath() {
+  return path.join(getConfigDir(), 'settings.json');
+}
+
+/**
+ * Read existing config or create default
+ * @returns {Object}
+ */
+function readConfig() {
+  const configPath = getConfigPath();
+
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.log(chalk.yellow('   ⚠️  Config file corrupted, creating new...'));
+    }
+  }
+
+  return {
+    env: {},
+    permissions: {
+      allow: [],
+      deny: []
+    }
+  };
+}
+
+/**
+ * Update Claude Code configuration
+ * @param {Object} answers - User answers from CLI
+ * @returns {Promise<void>}
+ */
+export async function updateConfig(answers) {
+  const configPath = getConfigPath();
+  const configDir = getConfigDir();
+
+  // Ensure config directory exists
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+    console.log(chalk.gray(`   Created config directory: ${configDir}`));
+  }
+
+  // Read existing config
+  const config = readConfig();
+
+  // Prepare model mapping
+  const modelMap = {
+    opus: 'claude-opus-4-8',
+    sonnet: 'claude-sonnet-4-6',
+    haiku: 'claude-haiku-4-5-20251001'
+  };
+
+  // Update env variables
+  config.env = {
+    ANTHROPIC_AUTH_TOKEN: answers.authToken,
+    ANTHROPIC_BASE_URL: answers.baseUrl,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: modelMap.opus,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: modelMap.sonnet,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: modelMap.haiku,
+    CLAUDE_CODE_SUBAGENT_MODEL: modelMap[answers.model] || modelMap.sonnet,
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    API_TIMEOUT_MS: '3000000'
+  };
+
+  // Add default permissions if not exists
+  if (!config.permissions) {
+    config.permissions = {
+      allow: [],
+      deny: []
+    };
+  }
+
+  // Write config
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(chalk.gray(`   Updated: ${configPath}`));
+}
+
+/**
+ * Read current configuration
+ * @returns {Object|null}
+ */
+export function readCurrentConfig() {
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get a specific config value
+ * @param {string} key - Config key
+ * @returns {string|null}
+ */
+export function getConfigValue(key) {
+  const config = readCurrentConfig();
+  if (!config || !config.env) return null;
+  return config.env[key] || null;
+}

package/src/env.js

@@ -0,0 +1,101 @@
+/**
+ * Environment Variable Manager Module
+ * Handles setting permanent environment variables across OS
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import chalk from 'chalk';
+
+/**
+ * Set environment variable for Windows (PowerShell)
+ * @param {string} key - Environment variable name
+ * @param {string} value - Environment variable value
+ */
+function setWindows(key, value) {
+  const escapedValue = value.replace(/"/g, '\\"');
+  const cmd = `[Environment]::SetEnvironmentVariable("${key}", "${escapedValue}", "User")`;
+
+  execSync(`powershell -Command "${cmd}"`, {
+    stdio: 'inherit',
+    shell: true
+  });
+}
+
+/**
+ * Set environment variable for macOS/Linux (bash/zsh)
+ * @param {string} key - Environment variable name
+ * @param {string} value - Environment variable value
+ * @param {string} shellType - 'bash' or 'zsh'
+ */
+async function setUnix(key, value, shellType) {
+  const configFile = shellType === 'zsh' ? '.zshrc' : '.bashrc';
+  const exportLine = `\nexport ${key}="${value}"\n`;
+
+  // Check if export already exists
+  const homeDir = process.env.HOME;
+  const configPath = `${homeDir}/${configFile}`;
+
+  let content = '';
+  if (fs.existsSync(configPath)) {
+    content = fs.readFileSync(configPath, 'utf-8');
+
+    // Check if key already exists
+    const regex = new RegExp(`^export\\s+${key}=`, 'm');
+    if (regex.test(content)) {
+      // Replace existing export
+      content = content.replace(
+        new RegExp(`^export\\s+${key}=.*$\\n?`, 'm'),
+        `export ${key}="${value}"\n`
+      );
+    } else {
+      // Append new export
+      content += exportLine;
+    }
+  } else {
+    content = exportLine;
+  }
+
+  fs.writeFileSync(configPath, content);
+  console.log(chalk.gray(`   Added to ~/${configFile}`));
+}
+
+/**
+ * Set environment variable permanently
+ * @param {string} key - Environment variable name
+ * @param {string} value - Environment variable value
+ * @param {string} os - Operating system: 'windows', 'macos', or 'linux'
+ * @returns {Promise<void>}
+ */
+export async function setEnvironmentVariable(key, value, os) {
+  console.log(chalk.gray(`   Setting ${key}=${value.substring(0, 10)}...`));
+
+  try {
+    if (os === 'windows') {
+      setWindows(key, value);
+    } else {
+      const shellType = os === 'macos' ? 'zsh' : 'bash';
+      await setUnix(key, value, shellType);
+    }
+  } catch (error) {
+    throw new Error(`Failed to set environment variable ${key}: ${error.message}`);
+  }
+}
+
+/**
+ * Get environment variable (current session only)
+ * @param {string} key - Environment variable name
+ * @returns {string|null}
+ */
+export function getEnv(key) {
+  return process.env[key] || null;
+}
+
+/**
+ * Check if environment variable is set
+ * @param {string} key - Environment variable name
+ * @returns {boolean}
+ */
+export function hasEnv(key) {
+  return key in process.env;
+}

package/src/installer.js

@@ -0,0 +1,60 @@
+/**
+ * Claude Code Installer Module
+ * Handles installation of Claude Code CLI
+ */
+
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Install Claude Code using bunx
+ * @returns {Promise<void>}
+ */
+export async function installClaude() {
+  try {
+    console.log(chalk.gray('   Running: bunx @anthropic-ai/claude-code'));
+
+    execSync('bunx @anthropic-ai/claude-code', {
+      stdio: 'inherit',
+      env: { ...process.env }
+    });
+  } catch (error) {
+    // If bunx fails, try npm
+    console.log(chalk.yellow('   bunx not available, trying npm...'));
+
+    try {
+      execSync('npx @anthropic-ai/claude-code', {
+        stdio: 'inherit',
+        env: { ...process.env }
+      });
+    } catch (npmError) {
+      throw new Error('Không thể cài đặt Claude Code. Vui lòng kiểm tra kết nối mạng.');
+    }
+  }
+}
+
+/**
+ * Check if Claude Code is already installed
+ * @returns {boolean}
+ */
+export function isClaudeInstalled() {
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get Claude Code version
+ * @returns {string|null}
+ */
+export function getClaudeVersion() {
+  try {
+    const version = execSync('claude --version', { encoding: 'utf-8' });
+    return version.trim();
+  } catch {
+    return null;
+  }
+}