pokt-cli 1.0.0

package/README.md

@@ -0,0 +1,96 @@
+# Pokt CLI
+
+CLI de **Vibe Coding** com IA: OpenRouter, Ollama (local e cloud), Gemini e provedor Pokt (controller).
+
+## Requisitos
+
+- **Node.js** >= 18.0.0
+
+## Instalação
+
+```bash
+# Instalação global
+npm install -g pokt-cli
+
+# Ou use sem instalar
+npx pokt-cli
+```
+
+## Uso
+
+Sem argumentos, o Pokt abre um menu interativo:
+
+```bash
+pokt
+```
+
+Ou use os comandos diretamente:
+
+```bash
+pokt chat              # Iniciar chat (Vibe Coding)
+pokt models list       # Listar modelos
+pokt provider use openrouter
+pokt config show
+pokt --help
+```
+
+## Comandos
+
+| Comando | Descrição |
+|--------|-----------|
+| `pokt` | Menu interativo |
+| `pokt chat` | Iniciar sessão de chat com a IA |
+| `pokt config <action>` | Configurar chaves e tokens |
+| `pokt models <action>` | Gerenciar modelos (listar, adicionar, trocar) |
+| `pokt provider use <provider>` | Trocar provedor de API |
+| `pokt mcp [action]` | Gerenciar servidores MCP (ferramentas externas) |
+
+### Config (`config`)
+
+- `pokt config show` — Mostra a configuração atual (tokens mascarados).
+- `pokt config set-openrouter -v <token>` — Token OpenRouter.
+- `pokt config set-ollama -v <url>` — URL base do Ollama local.
+- `pokt config set-ollama-cloud -v <key>` — API key Ollama Cloud.
+- `pokt config set-gemini -v <key>` — API key Google Gemini.
+- `pokt config set-pokt-token -v <token>` — Token do controller Pokt.
+- `pokt config clear-openrouter` — Remove o token OpenRouter.
+
+### Modelos (`models`)
+
+- `pokt models list` — Lista modelos registrados e o ativo.
+- `pokt models fetch-openrouter` — Busca modelos disponíveis no OpenRouter.
+- `pokt models fetch-ollama` — Busca modelos do Ollama local.
+- `pokt models fetch-ollama-cloud` — Busca modelos do Ollama Cloud.
+- `pokt models add-openrouter`, `add-ollama`, `add-ollama-cloud` — Adiciona modelo (use `-i <id>`).
+- `pokt models use -i <id> -p <provider>` — Define o modelo ativo.
+
+### Provedores (`provider`)
+
+Provedores suportados: `controller` (Pokt), `openrouter`, `gemini`, `ollama`, `ollama-cloud`.
+
+```bash
+pokt provider use openrouter
+pokt provider use ollama
+```
+
+## Desenvolvimento
+
+```bash
+# Clonar e instalar
+git clone https://github.com/PoktWeb/Pokt_CLI.git
+cd Pokt_CLI
+npm install
+
+# Desenvolvimento (executa o TypeScript direto)
+npm run dev
+
+# Build
+npm run build
+
+# Executar após o build
+npm start
+```
+
+## Licença
+
+ISC · **PoktWeb**

package/dist/auth/google.d.ts

@@ -0,0 +1 @@
+export declare function loginWithGoogle(): Promise<void>;

package/dist/auth/google.js

@@ -0,0 +1,49 @@
+import { OAuth2Client } from 'google-auth-library';
+import http from 'http';
+import url from 'url';
+import open from 'open';
+import { config } from '../config.js';
+import chalk from 'chalk';
+import ora from 'ora';
+const REDIRECT_URI = 'http://localhost:3000/oauth2callback';
+export async function loginWithGoogle() {
+    const clientId = config.get('googleClientId');
+    const clientSecret = config.get('googleClientSecret');
+    if (!clientId || !clientSecret) {
+        console.log(chalk.red('\nError: Google OAuth Client ID or Secret not configured.'));
+        console.log(chalk.yellow('To use Google Login, follow these steps:'));
+        console.log(chalk.gray('1. Create a project at: https://console.cloud.google.com/'));
+        console.log(chalk.gray('2. Enable the "Generative Language API"'));
+        console.log(chalk.gray('3. Create OAuth 2.0 Client ID (Type: Web application)'));
+        console.log(chalk.gray(`4. Add Authorized redirect URI: ${REDIRECT_URI}`));
+        console.log(chalk.yellow('\nThen configure Pokt CLI:'));
+        console.log(chalk.cyan(`   pokt config set-google-client-id -v YOUR_CLIENT_ID`));
+        console.log(chalk.cyan(`   pokt config set-google-client-secret -v YOUR_CLIENT_SECRET`));
+        return;
+    }
+    const spinner = ora('Starting Google Login...').start();
+    const oAuth2Client = new OAuth2Client(clientId, clientSecret, REDIRECT_URI);
+    const authorizeUrl = oAuth2Client.generateAuthUrl({
+        access_type: 'offline',
+        scope: ['https://www.googleapis.com/auth/generative-language'],
+    });
+    const server = http.createServer(async (req, res) => {
+        try {
+            if (req.url && req.url.includes('/oauth2callback') && req.url.includes('code=')) {
+                const qs = new url.URL(req.url, 'http://localhost:3000').searchParams;
+                const code = qs.get('code');
+                res.end('Authentication successful! You can close this tab.');
+                server.close();
+                const { tokens } = await oAuth2Client.getToken(code);
+                config.set('googleToken', tokens);
+                console.log(chalk.green('\n✔ Google account connected successfully.'));
+            }
+        }
+        catch (e) {
+            console.error(chalk.red(`\nAuthentication failed: ${e.message}`));
+            res.end('Authentication failed.');
+        }
+    }).listen(3000);
+    spinner.succeed(chalk.blue('Opening browser for Google login...'));
+    await open(authorizeUrl);
+}

package/dist/bin/pokt.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/pokt.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { configCommand } from '../commands/config.js';
+import { modelsCommand } from '../commands/models.js';
+import { chatCommand } from '../commands/chat.js';
+import { providerCommand } from '../commands/provider.js';
+import { mcpCommand } from '../commands/mcp.js';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { ui } from '../ui.js';
+const argv = hideBin(process.argv);
+if (argv.length === 0) {
+    showMenu();
+}
+else {
+    yargs(argv)
+        .scriptName('pokt')
+        .usage('$0 <cmd> [args]')
+        .command(configCommand)
+        .command(modelsCommand)
+        .command(chatCommand)
+        .command(providerCommand)
+        .command(mcpCommand)
+        .demandCommand(1, 'You need at least one command before moving on')
+        .help()
+        .parse();
+}
+async function showMenu() {
+    const { getEffectiveActiveModel, PROVIDER_LABELS } = await import('../config.js');
+    const active = getEffectiveActiveModel();
+    const providerLabel = active ? (PROVIDER_LABELS[active.provider] ?? active.provider) : 'No provider';
+    console.log('');
+    console.log(ui.banner());
+    console.log(ui.statusLine(providerLabel));
+    console.log('');
+    console.log(ui.separator());
+    console.log('');
+    const response = await prompts({
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+            { title: '💬 Start Chat (Vibe Coding)', value: 'chat' },
+            { title: '🤖 Select AI Model', value: 'models' },
+            { title: '➕ Add / sync models', value: 'add-models' },
+            { title: '🏠 Switch API Provider (casa de API)', value: 'provider' },
+            { title: '🔌 MCP Servers (tools externos)', value: 'mcp' },
+            { title: '⚙️  Configure API Keys / Tokens', value: 'config' },
+            { title: '❌ Exit', value: 'exit' }
+        ]
+    });
+    if (!response.action || response.action === 'exit') {
+        process.exit(0);
+    }
+    if (response.action === 'chat') {
+        const { chatCommand } = await import('../commands/chat.js');
+        chatCommand.handler({ fromMenu: true });
+    }
+    else if (response.action === 'models') {
+        await handleModelsMenu();
+    }
+    else if (response.action === 'add-models') {
+        await handleAddModelsMenu();
+    }
+    else if (response.action === 'provider') {
+        await handleProviderMenu();
+    }
+    else if (response.action === 'config') {
+        await handleConfigMenu();
+    }
+    else if (response.action === 'mcp') {
+        const { mcpCommand } = await import('../commands/mcp.js');
+        await mcpCommand.handler({ action: 'list' });
+        const mcpResp = await prompts({
+            type: 'select',
+            name: 'mcpAction',
+            message: 'MCP:',
+            choices: [
+                { title: '🧪 Test connection', value: 'test' },
+                { title: '🔙 Back', value: 'back' }
+            ]
+        });
+        if (mcpResp.mcpAction === 'back')
+            return showMenu();
+        await mcpCommand.handler({ action: mcpResp.mcpAction });
+        return showMenu();
+    }
+}
+async function handleModelsMenu(providerFilter) {
+    const { config, getEffectiveActiveModel, PROVIDER_LABELS, ALL_PROVIDERS } = await import('../config.js');
+    let allModels = config.get('registeredModels');
+    if (!Array.isArray(allModels)) {
+        const defaults = [
+            { provider: 'openrouter', id: 'google/gemini-2.0-flash-001' },
+            { provider: 'ollama', id: 'llama3' }
+        ];
+        config.set('registeredModels', defaults);
+        allModels = defaults;
+    }
+    const active = getEffectiveActiveModel();
+    // Primeira tela: escolher categoria (provedor)
+    if (providerFilter === undefined) {
+        const categoryChoices = [
+            ...ALL_PROVIDERS.map(p => ({
+                title: `${active?.provider === p ? '★ ' : ''}${PROVIDER_LABELS[p] || p}`,
+                value: p
+            })),
+            { title: '➕ Add / sync models', value: 'go-add-models' },
+            { title: '🔙 Back', value: 'back' }
+        ];
+        const cat = await prompts({
+            type: 'select',
+            name: 'category',
+            message: 'Select category (provider):',
+            choices: categoryChoices
+        });
+        if (cat.category === 'back')
+            return showMenu();
+        if (cat.category === 'go-add-models')
+            return handleAddModelsMenu();
+        return handleModelsMenu(cat.category);
+    }
+    // Segunda tela: listar modelos da categoria escolhida
+    const providerModels = allModels.filter((m) => m.provider === providerFilter);
+    const label = PROVIDER_LABELS[providerFilter] || providerFilter;
+    const choices = [
+        ...providerModels.map((m, i) => ({
+            title: `${active?.id === m.id && active?.provider === m.provider ? '★ ' : ''}${m.id}`,
+            value: i
+        })),
+        ...(providerModels.length === 0
+            ? [{ title: '➕ Nenhum modelo — ir para Add / sync models', value: 'go-add-models' }]
+            : []),
+        { title: '🔙 Back to categories', value: 'back-categories' }
+    ];
+    const response = await prompts({
+        type: 'select',
+        name: 'modelIdx',
+        message: `${label} — choose a model:`,
+        choices
+    });
+    if (response.modelIdx === 'back-categories')
+        return handleModelsMenu();
+    if (response.modelIdx === 'go-add-models')
+        return handleAddModelsMenu();
+    if (typeof response.modelIdx === 'number') {
+        const selected = providerModels[response.modelIdx];
+        config.set('activeModel', selected);
+        console.log(ui.success(`Active model set to [${selected.provider}] ${selected.id}\n`));
+        return showMenu();
+    }
+}
+/** Menu para adicionar/sincronizar modelos: OpenRouter (API), Ollama local (GET /api/tags), Ollama Cloud (add por ID). */
+async function handleAddModelsMenu() {
+    const response = await prompts({
+        type: 'select',
+        name: 'action',
+        message: 'Add or sync models from which provider?',
+        choices: [
+            { title: 'OpenRouter — sync all from API', value: 'fetch-openrouter' },
+            { title: 'Ollama (local) — sync from your Ollama (list models)', value: 'fetch-ollama' },
+            { title: 'Ollama Cloud — sync from API', value: 'fetch-ollama-cloud' },
+            { title: 'OpenRouter — add model by ID', value: 'add-openrouter' },
+            { title: 'Ollama (local) — add model by ID', value: 'add-ollama' },
+            { title: 'Ollama Cloud — add model by ID', value: 'add-ollama-cloud' },
+            { title: '🔙 Back', value: 'back' }
+        ]
+    });
+    if (response.action === 'back')
+        return showMenu();
+    const addActions = ['add-openrouter', 'add-ollama', 'add-ollama-cloud'];
+    if (addActions.includes(response.action)) {
+        const idPrompt = await prompts({
+            type: 'text',
+            name: 'id',
+            message: response.action === 'add-openrouter'
+                ? 'Model ID (ex: google/gemini-2.5-flash):'
+                : 'Model ID (ex: llama3):'
+        });
+        const id = typeof idPrompt.id === 'string' ? idPrompt.id.trim() : '';
+        if (id) {
+            const { modelsCommand } = await import('../commands/models.js');
+            await modelsCommand.handler({ action: response.action, id });
+        }
+        else {
+            console.log(ui.warn('No ID entered.'));
+        }
+        return handleAddModelsMenu();
+    }
+    const { modelsCommand } = await import('../commands/models.js');
+    await modelsCommand.handler({ action: response.action });
+    return handleAddModelsMenu();
+}
+async function handleConfigMenu() {
+    const { config } = await import('../config.js');
+    const response = await prompts({
+        type: 'select',
+        name: 'type',
+        message: 'Which setting to configure?',
+        choices: [
+            { title: 'View current config', value: 'show' },
+            { title: 'Pokt Token (do painel — só isso para usar Controller)', value: 'set-pokt-token' },
+            { title: 'OpenRouter Token', value: 'set-openrouter' },
+            { title: 'Gemini API Key', value: 'set-gemini' },
+            { title: 'Ollama Base URL (local)', value: 'set-ollama' },
+            { title: 'Ollama Cloud API Key', value: 'set-ollama-cloud' },
+            { title: '🔙 Back', value: 'back' }
+        ]
+    });
+    if (response.type === 'back')
+        return showMenu();
+    if (response.type === 'show') {
+        const { getControllerBaseUrl } = await import('../config.js');
+        const openrouter = config.get('openrouterToken');
+        const gemini = config.get('geminiApiKey');
+        const ollama = config.get('ollamaBaseUrl');
+        const ollamaCloud = config.get('ollamaCloudApiKey');
+        const poktToken = config.get('poktToken');
+        console.log(chalk.blue('\nCurrent config (tokens masked):'));
+        console.log(ui.dim('  Controller URL:'), getControllerBaseUrl(), ui.dim('(já configurado)'));
+        console.log(ui.dim('  Pokt Token:'), poktToken ? poktToken.slice(0, 10) + '****' : '(not set)');
+        console.log(ui.dim('  OpenRouter Token:'), openrouter ? openrouter.slice(0, 8) + '****' : '(not set)');
+        console.log(ui.dim('  Gemini API Key:'), gemini ? gemini.slice(0, 8) + '****' : '(not set)');
+        console.log(ui.dim('  Ollama Base URL (local):'), ollama || '(not set)');
+        console.log(ui.dim('  Ollama Cloud API Key:'), ollamaCloud ? ollamaCloud.slice(0, 8) + '****' : '(not set)');
+        console.log(ui.warn('\nTokens are stored in your user config directory. Do not share it.\n'));
+        return handleConfigMenu();
+    }
+    const msg = response.type === 'set-pokt-token'
+        ? 'Token gerado no painel (pk_...):'
+        : `Enter the value for ${response.type}:`;
+    const valueResponse = await prompts({
+        type: 'text',
+        name: 'val',
+        message: msg
+    });
+    if (valueResponse.val) {
+        const keyMap = {
+            'set-gemini': 'geminiApiKey',
+            'set-openrouter': 'openrouterToken',
+            'set-ollama': 'ollamaBaseUrl',
+            'set-ollama-cloud': 'ollamaCloudApiKey',
+            'set-pokt-token': 'poktToken'
+        };
+        const key = keyMap[response.type];
+        config.set(key, key === 'ollamaBaseUrl' ? valueResponse.val.replace(/\/$/, '') : valueResponse.val);
+        if (key === 'poktToken') {
+            const controllerModel = { provider: 'controller', id: 'default' };
+            const models = config.get('registeredModels');
+            if (!models.some((m) => m.provider === 'controller' && m.id === 'default')) {
+                config.set('registeredModels', [controllerModel, ...models]);
+            }
+            config.set('activeModel', controllerModel);
+        }
+        console.log(ui.success('Config updated.\n'));
+    }
+    return handleConfigMenu();
+}
+async function handleProviderMenu() {
+    const { config, getEffectiveActiveModel, PROVIDER_LABELS, ALL_PROVIDERS } = await import('../config.js');
+    let models = config.get('registeredModels');
+    const hasControllerUrl = !!(config.get('controllerBaseUrl'));
+    const hasPoktToken = !!(config.get('poktToken'));
+    if ((hasControllerUrl || hasPoktToken) && !models.some((m) => m.provider === 'controller')) {
+        models = [{ provider: 'controller', id: 'default' }, ...models];
+        config.set('registeredModels', models);
+    }
+    const active = getEffectiveActiveModel();
+    // Mostra todos os provedores (Ollama, Gemini, OpenRouter, Controller e quaisquer outros futuros)
+    const choices = ALL_PROVIDERS.map(p => ({
+        title: `${active?.provider === p ? '★ ' : ''}${PROVIDER_LABELS[p] || p}`,
+        value: p
+    }));
+    const response = await prompts({
+        type: 'select',
+        name: 'provider',
+        message: 'Choose API provider (casa de API):',
+        choices: [...choices, { title: '🔙 Back', value: 'back' }]
+    });
+    if (response.provider === 'back')
+        return showMenu();
+    const currentActive = getEffectiveActiveModel();
+    const model = (currentActive?.provider === response.provider)
+        ? currentActive
+        : models.find((m) => m.provider === response.provider);
+    if (model) {
+        config.set('activeModel', model);
+        const label = PROVIDER_LABELS[response.provider] || response.provider;
+        console.log(ui.success(`Primary provider set to ${label}.\n`));
+    }
+    else {
+        if (response.provider === 'controller') {
+            console.log(ui.error('Controller model not found. Add it with: pokt config set-pokt-token -v <token>'));
+        }
+        else if (response.provider === 'openrouter') {
+            console.log(ui.error('No OpenRouter model. Run: pokt models fetch-openrouter then pokt models list'));
+        }
+        else {
+            console.log(ui.error(`No model for provider "${response.provider}". Run: pokt models list and add one.`));
+        }
+    }
+    return showMenu();
+}

package/dist/chat/client.d.ts

@@ -0,0 +1,3 @@
+import OpenAI from 'openai';
+import { ModelConfig } from '../config.js';
+export declare function getClient(modelConfig: ModelConfig): Promise<InstanceType<typeof OpenAI>>;

package/dist/chat/client.js

@@ -0,0 +1,59 @@
+import OpenAI from 'openai';
+import { config, getControllerBaseUrl } from '../config.js';
+export async function getClient(modelConfig) {
+    if (modelConfig.provider === 'controller') {
+        const baseUrl = getControllerBaseUrl();
+        const token = config.get('poktToken');
+        if (!token) {
+            throw new Error('Token Pokt não configurado. No painel gere um token e use: pokt config set-pokt-token -v <token>');
+        }
+        return new OpenAI({
+            baseURL: `${baseUrl}/api/v1`,
+            apiKey: token,
+            defaultHeaders: {
+                'HTTP-Referer': 'https://github.com/pokt-cli',
+                'X-Title': 'Pokt CLI',
+            }
+        });
+    }
+    else if (modelConfig.provider === 'openrouter') {
+        return new OpenAI({
+            baseURL: 'https://openrouter.ai/api/v1',
+            apiKey: config.get('openrouterToken'),
+            defaultHeaders: {
+                'HTTP-Referer': 'https://github.com/pokt-cli',
+                'X-Title': 'Pokt CLI',
+            }
+        });
+    }
+    else if (modelConfig.provider === 'gemini') {
+        const apiKey = config.get('geminiApiKey');
+        if (!apiKey) {
+            throw new Error('Gemini API key not set. Use: pokt config set-gemini -v <key>');
+        }
+        return new OpenAI({
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+            apiKey: apiKey,
+        });
+    }
+    else if (modelConfig.provider === 'ollama-cloud') {
+        const apiKey = config.get('ollamaCloudApiKey');
+        if (!apiKey) {
+            throw new Error('Ollama Cloud API key não configurada. Crie uma em https://ollama.com/settings/keys e use: pokt config set-ollama-cloud -v <key>');
+        }
+        return new OpenAI({
+            baseURL: 'https://ollama.com/v1',
+            apiKey,
+            defaultHeaders: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+    }
+    else {
+        // Ollama (local) — não precisa de API key
+        return new OpenAI({
+            baseURL: `${config.get('ollamaBaseUrl')}/v1`,
+            apiKey: 'ollama',
+        });
+    }
+}

package/dist/chat/loop.d.ts

@@ -0,0 +1,2 @@
+import { ModelConfig } from '../config.js';
+export declare function startChatLoop(modelConfig: ModelConfig): Promise<void>;