smart-aipi 1.3.0

package/README.md

@@ -0,0 +1,183 @@
+# Smart AIPI CLI
+
+CLI for [Smart AIPI](https://smartaipi.com) — OpenAI-compatible API at 75% off.
+
+## Install
+
+```bash
+npm install -g smart-aipi
+```
+
+Or with Homebrew:
+
+```bash
+brew tap smart-aipi/tap
+brew install smart-aipi
+```
+
+## Quick Start
+
+```bash
+# Create an account
+smart-aipi signup
+
+# Create an API key
+smart-aipi keys create
+
+# Set environment variables
+export OPENAI_BASE_URL=https://api.smartaipi.com/v1
+export OPENAI_API_KEY=sk-your-key
+
+# Done — your AI tools now use Smart AIPI
+```
+
+## Commands
+
+### Account
+
+| Command | Description |
+|---------|-------------|
+| `smart-aipi signup` | Create a new account |
+| `smart-aipi login` | Log in |
+| `smart-aipi logout` | Log out |
+| `smart-aipi status` | Show login status |
+| `smart-aipi me` | Show account info |
+| `smart-aipi usage` | Show credits and usage |
+
+### API Keys
+
+| Command | Description |
+|---------|-------------|
+| `smart-aipi keys list` | List your API keys |
+| `smart-aipi keys create` | Create a new API key |
+| `smart-aipi keys revoke <id>` | Revoke an API key |
+
+### Tokens (for MCP)
+
+| Command | Description |
+|---------|-------------|
+| `smart-aipi tokens list` | List account tokens |
+| `smart-aipi tokens create` | Create a token for MCP server |
+
+### Documentation
+
+| Command | Description |
+|---------|-------------|
+| `smart-aipi docs` | List all setup guides |
+| `smart-aipi docs <topic>` | Show setup guide for a specific tool |
+| `smart-aipi models` | List available models |
+| `smart-aipi models --live` | Fetch live model list from API |
+| `smart-aipi config` | Show base URL and env vars |
+
+#### Available docs topics
+
+- **Getting Started:** quickstart, models
+- **IDE & Agents:** cursor, cline, windsurf, continue, aider, opencode, codex-cli
+- **SDKs:** python, nodejs, langchain
+- **MCP Server:** mcp
+
+## Connecting to AI Tools
+
+### Cursor
+
+```
+Settings > Models > Override OpenAI Base URL
+Base URL: https://api.smartaipi.com/v1
+API Key: sk-your-key
+```
+
+### OpenCode
+
+Edit `~/.config/opencode/config.json`:
+
+```json
+{
+  "provider": {
+    "openai": {
+      "options": {
+        "baseURL": "https://api.smartaipi.com/v1",
+        "apiKey": "sk-your-key"
+      },
+      "models": {
+        "gpt-5.3-codex": {}
+      }
+    }
+  },
+  "model": "openai/gpt-5.3-codex"
+}
+```
+
+### Codex CLI
+
+```bash
+export OPENAI_BASE_URL=https://api.smartaipi.com/v1
+export OPENAI_API_KEY=sk-your-key
+codex "explain this code"
+```
+
+### Any OpenAI-compatible tool
+
+Just set `OPENAI_BASE_URL` and `OPENAI_API_KEY`. Run `smart-aipi docs <tool>` for specific guides.
+
+## Available Models
+
+### Codex (Code-optimized)
+- `gpt-5.3-codex` — latest, recommended
+- `gpt-5.2-codex`, `gpt-5.1-codex`, `gpt-5-codex`
+- `gpt-5.2-codex-mini`, `gpt-5.1-codex-mini`, `gpt-5-codex-mini`
+- `gpt-5.1-codex-max` — maximum context window
+
+### GPT-5
+- `gpt-5.2`, `gpt-5.1`, `gpt-5`
+
+### Image Generation
+- `gpt-image-latest` — always points to latest
+- `gpt-image-1.5`, `gpt-image-1-mini`
+
+### Free Tier
+- `gpt-4.1`, `gpt-4.1-mini`, `gpt-4.1-nano`
+- `gpt-5-mini`, `gpt-5-nano`
+- `gpt-4o`, `gpt-4o-mini`
+
+## MCP Server
+
+For AI agents that support MCP, install the companion server:
+
+```bash
+npm install -g @smart-aipi/mcp
+smart-aipi tokens create -n "MCP Token"
+```
+
+See `smart-aipi docs mcp` for full setup instructions.
+
+## License
+
+MIT
+
+## Development
+
+The published CLI runtime files are in:
+- `bin/cli.js`
+- `lib/*.js`
+
+TypeScript source files live in:
+- `src/bin/cli.ts`
+- `src/lib/*.ts`
+
+Validation commands:
+
+```bash
+npm test
+```
+
+Install TypeScript first if needed:
+
+```bash
+npm install --save-dev typescript @types/node
+```
+
+Then rebuild JS outputs from TS:
+
+```bash
+npm run build
+```

package/bin/cli.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Conf from 'conf';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { createRequire } from 'node:module';
+import { DOCS, TOPIC_LIST, DOC_CATEGORIES } from '../lib/docs.js';
+import { registerLoginCommand, saveAuthState } from '../lib/login.js';
+const API_BASE = process.env.SMART_AIPI_URL || 'https://api.smartaipi.com';
+const WEB_BASE = process.env.SMART_AIPI_WEB_URL || 'https://smartaipi.com';
+const require = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require('../package.json');
+const config = new Conf({ projectName: 'smart-aipi' });
+const program = new Command();
+program
+    .name('smart-aipi')
+    .description('CLI for Smart AIPI - OpenAI-compatible API at 75% off')
+    .version(CLI_VERSION);
+registerLoginCommand(program, {
+    config,
+    apiBase: API_BASE,
+    webBase: WEB_BASE
+});
+program
+    .command('signup')
+    .description('Create a new Smart AIPI account')
+    .action(async () => {
+    const answers = await inquirer.prompt([
+        { type: 'input', name: 'name', message: 'Name:' },
+        { type: 'input', name: 'email', message: 'Email:' },
+        { type: 'password', name: 'password', message: 'Password (min 8 chars):', mask: '*' }
+    ]);
+    if (answers.password.length < 8) {
+        console.log(chalk.red('Password must be at least 8 characters'));
+        return;
+    }
+    const spinner = ora('Creating account...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/auth/signup`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(answers)
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Signup failed'));
+            return;
+        }
+        saveAuthState(config, { token: data.token, email: data.email, userId: data.user_id });
+        spinner.succeed(chalk.green('Account created successfully!'));
+        console.log(chalk.dim(`  Email: ${data.email}`));
+        console.log(chalk.dim(`  Token saved to config`));
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+program
+    .command('logout')
+    .description('Log out of your Smart AIPI account')
+    .action(() => {
+    config.delete('token');
+    config.delete('email');
+    config.delete('userId');
+    console.log(chalk.green('Logged out successfully'));
+});
+const keys = program
+    .command('keys')
+    .description('Manage API keys');
+keys
+    .command('list')
+    .description('List your API keys')
+    .action(async () => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Fetching keys...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/keys`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to fetch keys'));
+            return;
+        }
+        spinner.stop();
+        if (!data.keys || data.keys.length === 0) {
+            console.log(chalk.dim('No API keys. Create one with: smart-aipi keys create'));
+            return;
+        }
+        console.log(chalk.bold('\nYour API Keys:\n'));
+        for (const key of data.keys) {
+            const enabled = key.enabled ?? key.Enabled;
+            const keyPrefix = key.key_prefix ?? key.KeyPrefix;
+            const keyName = key.name ?? key.Name;
+            const createdAt = key.created_at ?? key.CreatedAt;
+            const status = enabled ? chalk.green('active') : chalk.red('revoked');
+            console.log(`  ${chalk.cyan(keyPrefix)}...  ${keyName}  [${status}]`);
+            console.log(chalk.dim(`    Created: ${new Date(createdAt).toLocaleDateString()}`));
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+keys
+    .command('create')
+    .description('Create a new API key')
+    .option('-n, --name <name>', 'Name for the key', 'CLI Key')
+    .action(async (options) => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Creating key...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/keys/create`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ name: options.name })
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to create key'));
+            return;
+        }
+        spinner.succeed(chalk.green('API key created!'));
+        console.log();
+        console.log(chalk.yellow('  Save this key - you won\'t see it again!'));
+        console.log();
+        console.log(`  ${chalk.bold.cyan(data.key)}`);
+        console.log();
+        console.log(chalk.dim('  Use with: OPENAI_API_KEY=' + data.key));
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+keys
+    .command('revoke <key_id>')
+    .description('Revoke an API key')
+    .action(async (keyId) => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: `Revoke key ${keyId}?`,
+            default: false
+        }]);
+    if (!confirm)
+        return;
+    const spinner = ora('Revoking key...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/keys/revoke`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ key_id: keyId })
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to revoke key'));
+            return;
+        }
+        spinner.succeed(chalk.green('Key revoked successfully'));
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+const tokens = program
+    .command('tokens')
+    .description('Manage account tokens (for CLI/MCP)');
+tokens
+    .command('list')
+    .description('List your account tokens')
+    .action(async () => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Fetching tokens...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/tokens`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to fetch tokens'));
+            return;
+        }
+        spinner.stop();
+        if (!data.tokens || data.tokens.length === 0) {
+            console.log(chalk.dim('No account tokens.'));
+            return;
+        }
+        console.log(chalk.bold('\nYour Account Tokens:\n'));
+        for (const t of data.tokens) {
+            const status = t.revoked ? chalk.red('revoked') : chalk.green('active');
+            console.log(`  ${chalk.cyan(t.token_prefix)}...  ${t.name}  [${status}]`);
+            console.log(chalk.dim(`    ID: ${t.id}  Created: ${new Date(t.created_at).toLocaleDateString()}`));
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+tokens
+    .command('create')
+    .description('Create a new account token')
+    .option('-n, --name <name>', 'Name for the token', 'CLI Token')
+    .action(async (options) => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Creating token...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/tokens/create`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ name: options.name })
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to create token'));
+            return;
+        }
+        spinner.succeed(chalk.green('Account token created!'));
+        console.log();
+        console.log(chalk.yellow('  Save this token - you won\'t see it again!'));
+        console.log();
+        console.log(`  ${chalk.bold.cyan(data.token)}`);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+program
+    .command('usage')
+    .description('Show your usage summary and credits')
+    .action(async () => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Fetching usage...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/usage`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to fetch usage'));
+            return;
+        }
+        spinner.stop();
+        const credits = (data.credits / 100).toFixed(2);
+        console.log(chalk.bold('\n  Credits Balance: ') + chalk.green(`$${credits}`));
+        console.log();
+        console.log(chalk.bold('  Usage Summary'));
+        console.log(chalk.dim('  ─────────────────────────────────────'));
+        const fmt = (label, s) => {
+            const tokens = s.tokens >= 1000 ? (s.tokens / 1000).toFixed(1) + 'K' : String(s.tokens);
+            const cost = '$' + (s.cost / 100).toFixed(2);
+            console.log(`  ${label.padEnd(14)} ${tokens.padStart(10)} tokens   ${cost.padStart(8)}`);
+        };
+        fmt('Today', data.summary.today);
+        fmt('This Week', data.summary.week);
+        fmt('This Month', data.summary.month);
+        fmt('All Time', data.summary.all_time);
+        if (data.history && data.history.length > 0) {
+            console.log();
+            console.log(chalk.bold('  Recent Requests'));
+            console.log(chalk.dim('  ─────────────────────────────────────'));
+            for (const r of data.history.slice(0, 10)) {
+                const model = r.model.padEnd(20);
+                const tokens = String(r.total_tokens).padStart(8);
+                const cost = '$' + (r.cost / 100).toFixed(4);
+                console.log(chalk.dim(`  ${model} ${tokens} tok  ${cost}`));
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+program
+    .command('me')
+    .description('Show your account info')
+    .action(async () => {
+    const token = config.get('token');
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run: smart-aipi login'));
+        return;
+    }
+    const spinner = ora('Fetching account info...').start();
+    try {
+        const res = await fetch(`${API_BASE}/api/me`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail(chalk.red(data.error || 'Failed to fetch account info'));
+            return;
+        }
+        spinner.stop();
+        console.log(chalk.bold('\n  Account Info\n'));
+        console.log(`  ${chalk.dim('Name:')}     ${data.name || chalk.dim('not set')}`);
+        console.log(`  ${chalk.dim('Email:')}    ${data.email}`);
+        console.log(`  ${chalk.dim('Plan:')}     ${data.plan}`);
+        console.log(`  ${chalk.dim('Credits:')}  ${chalk.green('$' + (data.credits / 100).toFixed(2))}`);
+        console.log(`  ${chalk.dim('Verified:')} ${data.verified ? chalk.green('yes') : chalk.red('no')}`);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${err.message}`));
+    }
+});
+program
+    .command('status')
+    .description('Show current login status')
+    .action(() => {
+    const email = config.get('email');
+    const token = config.get('token');
+    if (!email || !token) {
+        console.log(chalk.dim('Not logged in'));
+        console.log(chalk.dim('Run: smart-aipi login'));
+        return;
+    }
+    console.log(chalk.green('Logged in'));
+    console.log(chalk.dim(`  Email: ${email}`));
+});
+program
+    .command('config')
+    .description('Show configuration for OpenAI-compatible tools')
+    .action(() => {
+    console.log(chalk.bold('\nConfiguration for OpenAI-compatible tools:\n'));
+    console.log(chalk.cyan('Base URL:'));
+    console.log(`  ${API_BASE}/v1\n`);
+    console.log(chalk.cyan('Environment variables:'));
+    console.log(`  OPENAI_BASE_URL=${API_BASE}/v1`);
+    console.log(`  OPENAI_API_KEY=<your-api-key>\n`);
+    console.log(chalk.dim('Get an API key with: smart-aipi keys create'));
+});
+program
+    .command('docs [topic]')
+    .description('Show setup guides (topics: quickstart, cursor, cline, opencode, mcp, models, ...)')
+    .action((topic) => {
+    if (!topic) {
+        console.log(chalk.bold('\n  Smart AIPI Documentation\n'));
+        console.log(chalk.cyan('  Available topics:\n'));
+        for (const [cat, topics] of Object.entries(DOC_CATEGORIES)) {
+            console.log(`  ${chalk.bold(cat)}`);
+            for (const t of topics) {
+                console.log(`    ${chalk.green(t.padEnd(14))} ${DOCS[t].title}`);
+            }
+            console.log();
+        }
+        console.log(chalk.dim('  Run: smart-aipi docs <topic>\n'));
+        return;
+    }
+    const doc = DOCS[topic];
+    if (!doc) {
+        console.log(chalk.red(`\n  Unknown topic: ${topic}`));
+        console.log(chalk.dim(`  Available: ${TOPIC_LIST.join(', ')}\n`));
+        return;
+    }
+    console.log(doc.content);
+});
+program
+    .command('models')
+    .description('List available models')
+    .option('--live', 'Fetch live model list from the API')
+    .action(async (options) => {
+    if (options.live) {
+        const spinner = ora('Fetching models...').start();
+        try {
+            const res = await fetch(`${API_BASE}/v1/models`);
+            const data = await res.json();
+            if (!res.ok) {
+                spinner.fail(chalk.red('Failed to fetch models'));
+                return;
+            }
+            spinner.stop();
+            console.log(chalk.bold('\n  Available Models (live)\n'));
+            const models = data.data || [];
+            models.sort((a, b) => a.id.localeCompare(b.id));
+            for (const m of models) {
+                console.log(`  ${chalk.green(m.id.padEnd(24))} ${chalk.dim(m.owned_by)}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            spinner.fail(chalk.red(`Error: ${err.message}`));
+        }
+    }
+    else {
+        console.log(DOCS['models'].content);
+    }
+});
+program.parse();

package/lib/docs.js

@@ -0,0 +1,311 @@
+import chalk from 'chalk';
+export const DOCS = {
+    'quickstart': {
+        title: 'Quick Start',
+        content: `
+  ${chalk.bold('Smart AIPI Quick Start')}
+
+  Smart AIPI is an OpenAI-compatible API. Set two env vars and go.
+
+  ${chalk.cyan('1. Install & sign up')}
+  ${chalk.dim('$ npm install -g smart-aipi')}
+  ${chalk.dim('$ smart-aipi signup')}
+  ${chalk.dim('$ smart-aipi keys create')}
+
+  ${chalk.cyan('2. Set environment variables')}
+  ${chalk.dim('export OPENAI_BASE_URL=https://api.smartaipi.com/v1')}
+  ${chalk.dim('export OPENAI_API_KEY=sk-your-api-key')}
+
+  ${chalk.cyan('3. Use with any OpenAI-compatible tool')}
+  Your existing code, SDKs, and AI tools work automatically.
+
+  ${chalk.cyan('Available topics:')}
+  cursor, cline, windsurf, continue, aider,
+  opencode, codex-cli, langchain, python, nodejs, mcp, models
+
+  ${chalk.dim('Run: smart-aipi docs <topic>')}
+`
+    },
+    'cursor': {
+        title: 'Cursor IDE',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Cursor')}
+
+  ${chalk.cyan('Setup')}
+  1. Open Cursor Settings (Cmd+, or Ctrl+,)
+  2. Go to "Models" section
+  3. Under "OpenAI API Key", enter your Smart AIPI key
+  4. Click "Override OpenAI Base URL"
+  5. Enter: ${chalk.green('https://api.smartaipi.com/v1')}
+  6. Select a model (e.g. gpt-5.3-codex) and start coding
+
+  ${chalk.cyan('Recommended models')}
+  - ${chalk.green('gpt-5.3-codex')} — best for code generation
+  - ${chalk.green('gpt-5.2-codex-mini')} — fast, cheaper
+  - ${chalk.green('gpt-5.1-codex-max')} — maximum context window
+`
+    },
+    'cline': {
+        title: 'Cline',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Cline')}
+
+  ${chalk.cyan('Option 1: Cline settings')}
+  In Cline settings, configure:
+  - API Provider: ${chalk.green('OpenAI Compatible')}
+  - Base URL: ${chalk.green('https://api.smartaipi.com/v1')}
+  - API Key: ${chalk.green('sk-your-smart-aipi-key')}
+  - Model: ${chalk.green('gpt-5.3-codex')}
+
+  ${chalk.cyan('Option 2: Environment variables')}
+  ${chalk.dim('export OPENAI_BASE_URL=https://api.smartaipi.com/v1')}
+  ${chalk.dim('export OPENAI_API_KEY=sk-your-smart-aipi-key')}
+`
+    },
+    'windsurf': {
+        title: 'Windsurf',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Windsurf')}
+
+  ${chalk.cyan('Setup')}
+  1. Open Windsurf Settings
+  2. Go to AI Provider settings
+  3. Select "OpenAI Compatible" as provider
+  4. Set Base URL: ${chalk.green('https://api.smartaipi.com/v1')}
+  5. Set API Key: ${chalk.green('sk-your-smart-aipi-key')}
+  6. Set Model: ${chalk.green('gpt-5.3-codex')}
+`
+    },
+    'continue': {
+        title: 'Continue',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Continue')}
+
+  Edit your Continue config (~/.continue/config.json):
+
+  ${chalk.dim(`{
+    "models": [{
+      "title": "Smart AIPI",
+      "provider": "openai",
+      "model": "gpt-5.3-codex",
+      "apiBase": "https://api.smartaipi.com/v1",
+      "apiKey": "sk-your-smart-aipi-key"
+    }]
+  }`)}
+`
+    },
+    'aider': {
+        title: 'Aider',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Aider')}
+
+  ${chalk.cyan('Setup')}
+  ${chalk.dim('export OPENAI_API_BASE=https://api.smartaipi.com/v1')}
+  ${chalk.dim('export OPENAI_API_KEY=sk-your-smart-aipi-key')}
+
+  Then run:
+  ${chalk.dim('aider --model openai/gpt-5.3-codex')}
+`
+    },
+    'opencode': {
+        title: 'OpenCode',
+        content: `
+  ${chalk.bold('Using Smart AIPI with OpenCode')}
+
+  Edit ~/.config/opencode/config.json:
+
+  ${chalk.dim(`{
+    "provider": {
+      "openai": {
+        "options": {
+          "baseURL": "https://api.smartaipi.com/v1",
+          "apiKey": "sk-your-smart-aipi-key"
+        },
+        "models": {
+          "gpt-5.3-codex": {}
+        }
+      }
+    },
+    "model": "openai/gpt-5.3-codex"
+  }`)}
+`
+    },
+    'codex-cli': {
+        title: 'Codex CLI',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Codex CLI')}
+
+  ${chalk.cyan('Setup')}
+  ${chalk.dim('export OPENAI_BASE_URL=https://api.smartaipi.com/v1')}
+  ${chalk.dim('export OPENAI_API_KEY=sk-your-smart-aipi-key')}
+
+  Then use Codex CLI as normal:
+  ${chalk.dim('codex "explain this code"')}
+
+  ${chalk.cyan('Or edit ~/.codex/config.toml')}
+  ${chalk.dim(`[api]
+  base_url = "https://api.smartaipi.com/v1"
+  api_key = "sk-your-smart-aipi-key"
+  model = "gpt-5.3-codex"`)}
+`
+    },
+    'langchain': {
+        title: 'LangChain',
+        content: `
+  ${chalk.bold('Using Smart AIPI with LangChain')}
+
+  ${chalk.cyan('Python')}
+  ${chalk.dim(`from langchain_openai import ChatOpenAI
+
+  llm = ChatOpenAI(
+      model="gpt-5.3-codex",
+      openai_api_base="https://api.smartaipi.com/v1",
+      openai_api_key="sk-your-smart-aipi-key"
+  )
+
+  response = llm.invoke("Hello!")`)}
+
+  ${chalk.cyan('JavaScript')}
+  ${chalk.dim(`import { ChatOpenAI } from "@langchain/openai";
+
+  const llm = new ChatOpenAI({
+    model: "gpt-5.3-codex",
+    configuration: {
+      baseURL: "https://api.smartaipi.com/v1",
+      apiKey: "sk-your-smart-aipi-key"
+    }
+  });`)}
+`
+    },
+    'python': {
+        title: 'Python (OpenAI SDK)',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Python')}
+
+  ${chalk.dim(`from openai import OpenAI
+
+  client = OpenAI(
+      base_url="https://api.smartaipi.com/v1",
+      api_key="sk-your-smart-aipi-key"
+  )
+
+  # Chat completions
+  response = client.chat.completions.create(
+      model="gpt-5.3-codex",
+      messages=[{"role": "user", "content": "Hello!"}]
+  )
+  print(response.choices[0].message.content)
+
+  # Image generation
+  image = client.images.generate(
+      model="gpt-image-latest",
+      prompt="A sunset over mountains"
+  )
+  print(image.data[0].url)`)}
+`
+    },
+    'nodejs': {
+        title: 'Node.js',
+        content: `
+  ${chalk.bold('Using Smart AIPI with Node.js')}
+
+  ${chalk.dim(`import OpenAI from 'openai';
+
+  const openai = new OpenAI({
+    baseURL: 'https://api.smartaipi.com/v1',
+    apiKey: 'sk-your-smart-aipi-key'
+  });
+
+  // Chat completions
+  const response = await openai.chat.completions.create({
+    model: 'gpt-5.3-codex',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  });
+  console.log(response.choices[0].message.content);
+
+  // Image generation
+  const image = await openai.images.generate({
+    model: 'gpt-image-latest',
+    prompt: 'A sunset over mountains'
+  });`)}
+`
+    },
+    'mcp': {
+        title: 'MCP Server Setup',
+        content: `
+  ${chalk.bold('Smart AIPI MCP Server')}
+
+  The MCP server lets AI agents manage your keys, check usage,
+  and access setup docs directly.
+
+  ${chalk.cyan('1. Install')}
+  ${chalk.dim('npm install -g @smart-aipi/mcp')}
+
+  ${chalk.cyan('2. Get an account token')}
+  ${chalk.dim('smart-aipi login')}
+  ${chalk.dim('smart-aipi tokens create -n "MCP Token"')}
+
+  ${chalk.cyan('3. Add to your AI tool')}
+
+  ${chalk.bold('Cursor / Cline / OpenCode')} — add to MCP settings:
+  ${chalk.dim(`{
+    "mcpServers": {
+      "smart-aipi": {
+        "command": "smart-aipi-mcp",
+        "env": { "SMART_AIPI_TOKEN": "your-token" }
+      }
+    }
+  }`)}
+
+  ${chalk.cyan('Available MCP tools')}
+  - smart_aipi_docs     — get setup guides
+  - smart_aipi_config   — get base URL and env vars
+  - smart_aipi_models   — list available models
+  - smart_aipi_list_keys   — list your API keys
+  - smart_aipi_create_key  — create a new API key
+  - smart_aipi_revoke_key  — revoke an API key
+  - smart_aipi_usage    — check credits and usage
+  - smart_aipi_me       — view account info
+`
+    },
+    'models': {
+        title: 'Available Models',
+        content: `
+  ${chalk.bold('Available Models')}
+
+  ${chalk.cyan('Codex Series (Code-optimized)')}
+  - ${chalk.green('gpt-5.3-codex')}      — latest, recommended for coding
+  - ${chalk.green('gpt-5.2-codex')}      — stable code generation
+  - ${chalk.green('gpt-5.1-codex')}      — code generation
+  - ${chalk.green('gpt-5-codex')}        — base codex model
+  - ${chalk.green('gpt-5.2-codex-mini')} — fast & efficient
+  - ${chalk.green('gpt-5.1-codex-mini')} — fast & efficient
+  - ${chalk.green('gpt-5-codex-mini')}   — fast & efficient
+  - ${chalk.green('gpt-5.1-codex-max')}  — maximum context window
+
+  ${chalk.cyan('GPT-5 Series')}
+  - ${chalk.green('gpt-5.2')}  — latest general-purpose
+  - ${chalk.green('gpt-5.1')}  — general-purpose
+  - ${chalk.green('gpt-5')}    — base GPT-5
+
+  ${chalk.cyan('Image Generation')}
+  - ${chalk.green('gpt-image-latest')} — always points to the latest model
+  - ${chalk.green('gpt-image-1.5')}    — frontier image generation
+  - ${chalk.green('gpt-image-1-mini')} — fast image generation
+
+  ${chalk.cyan('Free Tier Models')}
+  - gpt-4.1, gpt-4.1-mini, gpt-4.1-nano
+  - gpt-5-mini, gpt-5-nano
+  - gpt-4o, gpt-4o-mini
+
+  ${chalk.dim('Live list: smart-aipi models --live')}
+`
+    }
+};
+export const TOPIC_LIST = Object.keys(DOCS);
+export const DOC_CATEGORIES = {
+    'Getting Started': ['quickstart', 'models'],
+    'IDE & Agent Setup': ['cursor', 'cline', 'windsurf', 'continue', 'aider', 'opencode', 'codex-cli'],
+    'SDK & Framework': ['python', 'nodejs', 'langchain'],
+    'MCP Server': ['mcp']
+};

package/lib/login.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import open from 'open';
+const AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+const CALLBACK_HOST = '127.0.0.1';
+const AUTH_FAILURE_PAGES = {
+    invalidState: '<html><body style="font-family:sans-serif;text-align:center;padding:60px"><h2>Authorization Failed</h2><p>Invalid state parameter. Please try again.</p></body></html>',
+    missingToken: '<html><body style="font-family:sans-serif;text-align:center;padding:60px"><h2>Authorization Failed</h2><p>No token received. Please try again.</p></body></html>'
+};
+const AUTH_SUCCESS_PAGE = `<html><body style="font-family:system-ui,sans-serif;text-align:center;padding:60px;background:#f9fafb">
+<div style="max-width:400px;margin:0 auto;background:white;border-radius:16px;border:1px solid #e5e7eb;padding:40px">
+<div style="width:48px;height:48px;background:#dbeafe;border-radius:50%;display:flex;align-items:center;justify-content:center;margin:0 auto 16px">
+<svg width="24" height="24" fill="none" viewBox="0 0 24 24" stroke="#2563eb" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7"/></svg>
+</div>
+<h2 style="color:#111827;margin:0 0 8px;font-size:20px">CLI Authorized!</h2>
+<p style="color:#6b7280;margin:0;font-size:14px">You can close this tab and return to your terminal.</p>
+</div></body></html>`;
+function isHeadlessEnvironment() {
+    return !!(process.env.SSH_TTY ||
+        process.env.SSH_CONNECTION ||
+        (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY));
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function saveAuthState(config, { token, email, userId }) {
+    if (token)
+        config.set('token', token);
+    if (email)
+        config.set('email', email);
+    if (userId)
+        config.set('userId', userId);
+}
+function printLoginSuccess(email) {
+    console.log(chalk.green('\nLogged in successfully!'));
+    if (email)
+        console.log(chalk.dim(`  Email: ${email}`));
+    console.log(chalk.dim('  Token saved to config'));
+}
+async function hydrateUserFromToken(config, apiBase, token) {
+    try {
+        const meRes = await fetch(`${apiBase}/api/me`, {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        if (!meRes.ok)
+            return;
+        const me = (await meRes.json());
+        saveAuthState(config, { email: me.email, userId: me.id });
+    }
+    catch {
+    }
+}
+function closeServerSafely(server) {
+    if (server.listening) {
+        server.close();
+    }
+}
+function writeHtmlResponse(res, statusCode, body) {
+    res.writeHead(statusCode, { 'Content-Type': 'text/html' });
+    res.end(body);
+}
+async function loginWithBrowser({ config, apiBase, webBase }) {
+    const state = randomBytes(16).toString('hex');
+    return new Promise((resolve) => {
+        let settled = false;
+        const waiting = ora({ text: 'Waiting for authorization...', spinner: 'dots' });
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(ok);
+        };
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url ?? '/', `http://${CALLBACK_HOST}`);
+            if (url.pathname !== '/callback') {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const token = url.searchParams.get('token');
+            const returnedState = url.searchParams.get('state');
+            if (returnedState !== state) {
+                waiting.stop();
+                writeHtmlResponse(res, 400, AUTH_FAILURE_PAGES.invalidState);
+                closeServerSafely(server);
+                console.log(chalk.red('\nAuthorization failed: state mismatch'));
+                finish(false);
+                return;
+            }
+            if (!token) {
+                waiting.stop();
+                writeHtmlResponse(res, 400, AUTH_FAILURE_PAGES.missingToken);
+                closeServerSafely(server);
+                console.log(chalk.red('\nAuthorization failed: no token received'));
+                finish(false);
+                return;
+            }
+            waiting.stop();
+            saveAuthState(config, { token });
+            await hydrateUserFromToken(config, apiBase, token);
+            writeHtmlResponse(res, 200, AUTH_SUCCESS_PAGE);
+            closeServerSafely(server);
+            printLoginSuccess(config.get('email'));
+            finish(true);
+        });
+        server.on('error', (err) => {
+            waiting.stop();
+            console.log(chalk.red(`\nFailed to start callback server: ${formatError(err)}`));
+            finish(false);
+        });
+        server.listen(0, CALLBACK_HOST, () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                waiting.stop();
+                closeServerSafely(server);
+                console.log(chalk.red('\nFailed to determine callback server port.'));
+                finish(false);
+                return;
+            }
+            const port = address.port;
+            const authURL = `${webBase}/auth/cli?port=${port}&state=${state}`;
+            console.log(chalk.dim('Opening browser for authentication...'));
+            console.log(chalk.dim(`  If it doesn't open, visit: ${authURL}\n`));
+            open(authURL).catch(() => {
+                console.log(chalk.yellow('  Could not open browser automatically.'));
+                console.log(chalk.yellow(`  Open this URL manually: ${authURL}\n`));
+            });
+            waiting.start();
+            const timeout = setTimeout(() => {
+                waiting.stop();
+                closeServerSafely(server);
+                console.log(chalk.red('\nAuthorization timed out (5 minutes).'));
+                console.log(chalk.dim('  Try again or use: smart-aipi login --no-browser'));
+                finish(false);
+            }, AUTH_TIMEOUT_MS);
+            server.on('close', () => clearTimeout(timeout));
+        });
+    });
+}
+async function loginWithPrompt({ config, apiBase }) {
+    const answers = (await inquirer.prompt([
+        { type: 'input', name: 'email', message: 'Email:' },
+        { type: 'password', name: 'password', message: 'Password:', mask: '*' }
+    ]));
+    const spinner = ora('Logging in...').start();
+    try {
+        const res = await fetch(`${apiBase}/api/auth/login`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(answers)
+        });
+        const data = (await res.json());
+        if (!res.ok || !data.token || !data.email) {
+            spinner.fail(chalk.red(data.error || 'Login failed'));
+            return;
+        }
+        saveAuthState(config, { token: data.token, email: data.email, userId: data.user_id });
+        spinner.succeed(chalk.green('Logged in successfully!'));
+        console.log(chalk.dim(`  Email: ${data.email}`));
+        console.log(chalk.dim('  Token saved to config'));
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Error: ${formatError(err)}`));
+    }
+}
+export function registerLoginCommand(program, deps) {
+    program
+        .command('login')
+        .description('Log in to your Smart AIPI account')
+        .option('--no-browser', 'Use email/password prompt instead of browser')
+        .action(async (options) => {
+        const isHeadless = isHeadlessEnvironment();
+        if (options.browser === false || isHeadless) {
+            if (isHeadless && options.browser !== false) {
+                console.log(chalk.dim('Headless environment detected, using email/password login.\n'));
+            }
+            await loginWithPrompt({ config: deps.config, apiBase: deps.apiBase });
+        }
+        else {
+            await loginWithBrowser(deps);
+        }
+    });
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "smart-aipi",
+  "version": "1.3.0",
+  "description": "CLI for Smart AIPI - OpenAI-compatible API gateway",
+  "type": "module",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "bin": {
+    "smart-aipi": "bin/cli.js",
+    "saipi": "bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test:runtime": "node --check bin/cli.js && node --check lib/login.js && node --check lib/docs.js",
+    "test": "npm run build && npm run test:runtime"
+  },
+  "keywords": [
+    "openai",
+    "api",
+    "cli",
+    "ai",
+    "gpt",
+    "chatgpt"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "conf": "^12.0.0",
+    "inquirer": "^9.2.0",
+    "open": "^10.2.0",
+    "ora": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magic/smart-aipi.git"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.2",
+    "typescript": "^5.9.3"
+  }
+}