pokt-cli 1.0.11 → 1.0.12

package/dist/chat/loop.js

@@ -11,6 +11,7 @@ import { connectMcpServer, getAllMcpToolsOpenAI, callMcpTool, isMcpTool, disconn
 import { getMergedMcpServers } from '../mcp/project-mcp.js';
 import { runMcpFromBashMarkdown, stripExecutedStyleMcpBashBlocks, tryAutoMcpForListDatabases, } from './mcp-from-text.js';
 import { slimToolsForUpstreamPayload } from './slim-tools.js';
+import { emptyUsageAccumulator, mergeCompletionUsage, sendCliUsageTelemetryFireAndForget, } from './telemetry.js';
 /** Base do system prompt; a lista de ferramentas MCP é anexada em runtime quando houver servidores. */
 const SYSTEM_PROMPT_BASE = `You are Pokt CLI, an elite AI Software Engineer.
 Your goal is to help the user build, fix, and maintain software projects with high quality.
@@ -21,7 +22,7 @@ CORE CAPABILITIES:
 3.  **Problem Solving**: You analyze errors and propose/apply fixes.
 
 FUNCTION CALLING (native tools — USE THEM):
-- This chat uses OpenAI-style **tool_calls**. You MUST use the provided functions for actions: \`read_file\`, \`search_replace\`, \`write_file\`, \`run_command\`, \`list_files\`, etc., and any tool whose name starts with \`mcp_\`.
+- This chat uses OpenAI-style **tool_calls**. You MUST use the provided functions for actions: \`read_file\`, \`search_replace\`, \`write_file\`, \`run_command\`, \`list_files\`, \`delete_file\`, \`delete_directory\`, etc., and any tool whose name starts with \`mcp_\`.
 - **Edits vs rewrites**: For modifying existing files, prefer \`search_replace\` (old_string, new_string, path) — targeted, minimal changes. Use \`write_file\` only for new files or full rewrites. Always call \`read_file\` first to get exact content before \`search_replace\`.
 - **Avoid** shell lines like \`mcp_Something_tool "..."\` in markdown — the CLI may run them as **fallback** if they match a registered tool, but **native tool_calls are always better** (correct args, one round-trip).
 - For databases/APIs exposed via MCP, call the real \`mcp_*\` tools with the correct JSON arguments (e.g. Neon: run SQL via the server's SQL tool, not a invented command name).
@@ -41,6 +42,7 @@ GUIDELINES:
 - You have full access to the current terminal via \`run_command\` for \`npm install\`, \`tsc\`, etc. You may also emit **scripts executáveis** (Node, Python, npx, \`psql\`, etc.) via \`run_command\` when MCP não estiver disponível ou o usuário pedir código para rodar localmente.
 - **MCP tools**: Tools named \`mcp_<ServerName>_<toolName>\` connect to external services. Prefer them when they match the task.
 - **Never** return a completely empty assistant message: always include a short natural-language answer and/or use tool_calls. After tools run, summarize results for the user in Portuguese.
+- **Next.js app/pages conflict**: When build fails with "Conflicting app and page file" (pages/index.js vs app/page.tsx), resolve by calling \`delete_directory("app")\` to remove the app folder and keep only pages. Prefer tool_calls over shell blocks. On Windows, \`delete_directory\` is cross-platform and does not require rmdir/cmd.
 - **After MCP/SQL succeeds**: give a **short** confirmation plus a **markdown table** (or bullet list) for rows/columns — do **not** repeat bash blocks with mcp_* lines, raw tool JSON, or invented shell commands; the CLI already executed native tool_calls.
 - Be extremely concise in your explanations.
 - The current working directory is: ${process.cwd()}
@@ -412,7 +414,7 @@ Atalhos:
                 content: `Current Project Structure:\n${projectStructure}\n\n${structureHint}`,
             });
         }
-        await processLLMResponse(client, activeModel.id, messages, toolsForApi, sessionFileCtx);
+        await processLLMResponse(client, activeModel, messages, toolsForApi, sessionFileCtx);
         // Atualiza auto-save após resposta
         saveAuto(messages);
         // Captura última resposta do assistente para /copy (melhor esforço)
@@ -458,6 +460,61 @@ const CODE_EXT = /\.(py|js|ts|tsx|jsx|html|css|json|md|txt|java|go|rs|c|cpp|rb|p
 function isShellLikeBlock(lang) {
     return /^(bash|sh|shell|zsh|powershell|ps1|cmd|console)$/i.test(lang);
 }
+/** Comandos que resolvem conflito Next.js app/pages - executar via run_command quando em blocos shell. */
+function looksLikeNextJsConflictFix(code) {
+    const t = code.trim().toLowerCase();
+    if (/mcp_[a-z0-9_-]+/i.test(t))
+        return false; // MCP já tratado separadamente
+    return ((/\brmdir\b.*\bapp\b/.test(t) || /\bremove-item\b.*\bapp\b/i.test(t) || /\brm\s+-rf?\s+app\b/.test(t)) ||
+        (/\brmdir\b.*\.next\b/.test(t) || /\bremove-item\b.*\.next\b/i.test(t) || /\brm\s+-rf?\s+\.next\b/.test(t)));
+}
+/**
+ * Executa blocos shell (cmd, powershell) que parecem corrigir conflito Next.js.
+ * Fallback quando a IA coloca rmdir/Remove-Item em markdown em vez de usar delete_directory.
+ */
+async function executeShellBlocksFromContent(content) {
+    const codeBlockRe = /```(cmd|powershell|ps1|bash|sh)\s*\n([\s\S]*?)```/gi;
+    const executedBlocks = [];
+    let executed = false;
+    let m;
+    const isWin = process.platform === 'win32';
+    while ((m = codeBlockRe.exec(content)) !== null) {
+        const lang = (m[1] || '').toLowerCase();
+        const code = (m[2] || '').replace(/\r\n/g, '\n').trim();
+        if (!code || !looksLikeNextJsConflictFix(code))
+            continue;
+        const lines = code.split('\n').map((l) => l.trim()).filter(Boolean);
+        if (lines.length === 0)
+            continue;
+        for (const line of lines) {
+            if (/mcp_[a-z0-9_-]+/i.test(line))
+                continue;
+            const cmd = isWin && /^(bash|sh)$/.test(lang)
+                ? `cmd /c ${line.replace(/rm\s+-rf?\s+(\S+)/g, 'rmdir /s /q $1')}`
+                : line;
+            try {
+                if (toolsVerbose())
+                    console.log(ui.warn(`\n[Fallback] Executando: ${cmd}`));
+                else
+                    console.log(ui.dim(`\n[Fallback] Executando comando: ${cmd.slice(0, 60)}${cmd.length > 60 ? '…' : ''}`));
+                await executeTool('run_command', JSON.stringify({ command: cmd }));
+                executed = true;
+                executedBlocks.push({ start: m.index, end: m.index + m[0].length, command: cmd });
+                break;
+            }
+            catch {
+                // ignora falha
+            }
+        }
+    }
+    let displayContent = content;
+    for (let i = executedBlocks.length - 1; i >= 0; i--) {
+        const { start, end, command } = executedBlocks[i];
+        const placeholder = `\n${ui.dim('[Comando executado: ' + command.slice(0, 50) + (command.length > 50 ? '…' : '') + ']')}\n`;
+        displayContent = displayContent.substring(0, start) + placeholder + displayContent.substring(end);
+    }
+    return { executed, displayContent };
+}
 /**
  * Caminhos que o fallback nunca deve sobrescrever (config MCP, env, lockfile).
  */
@@ -665,16 +722,19 @@ async function applyCodeBlocksFromContent(content, sessionFileCtx) {
     }
     return { applied, displayContent };
 }
-async function createCompletionWithRetry(client, modelId, messages, toolsList, toolChoice = 'auto') {
+async function createCompletionWithRetry(client, modelId, messages, toolsList, toolChoice = 'auto', usageAcc) {
     let lastError;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
-            return await client.chat.completions.create({
+            const out = await client.chat.completions.create({
                 model: modelId,
                 messages,
                 tools: toolsList,
                 tool_choice: toolChoice,
             });
+            if (usageAcc)
+                mergeCompletionUsage(usageAcc, out);
+            return out;
         }
         catch (err) {
             lastError = err;
@@ -692,7 +752,7 @@ async function createCompletionWithRetry(client, modelId, messages, toolsList, t
 /**
  * Executa todas as rodadas de tool_calls até o modelo devolver mensagem sem ferramentas.
  */
-async function drainToolCalls(client, modelId, messages, toolsList, startMessage, spinner, sessionFileCtx) {
+async function drainToolCalls(client, modelId, messages, toolsList, startMessage, spinner, sessionFileCtx, usageAcc) {
     let message = startMessage;
     let writeFileExecuted = false;
     let anyToolExecuted = false;
@@ -737,7 +797,7 @@ async function drainToolCalls(client, modelId, messages, toolsList, startMessage
             });
         }
         spinner.start('Thinking...');
-        const completion = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto');
+        const completion = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto', usageAcc);
         spinner.stop();
         const nextMsg = getFirstChoiceMessage(completion);
         if (!nextMsg) {
@@ -747,20 +807,36 @@ async function drainToolCalls(client, modelId, messages, toolsList, startMessage
     }
     return { message, writeFileExecuted, anyToolExecuted, mcpToolExecuted };
 }
-async function processLLMResponse(client, modelId, messages, toolsList, sessionFileCtx) {
+function emitCliTelemetryForTurn(modelConfig, acc) {
+    const total = acc.prompt + acc.completion;
+    if (total <= 0)
+        return;
+    sendCliUsageTelemetryFireAndForget({
+        provider: modelConfig.provider,
+        model: modelConfig.id,
+        promptTokens: acc.prompt,
+        completionTokens: acc.completion,
+        totalTokens: total,
+        cost: acc.cost,
+    });
+}
+async function processLLMResponse(client, modelConfig, messages, toolsList, sessionFileCtx) {
     const spinner = ora('Thinking...').start();
+    const modelId = modelConfig.id;
+    const usageAcc = emptyUsageAccumulator();
     try {
-        let completion = await createCompletionWithRetry(client, modelId, messages, toolsList);
+        let completion = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto', usageAcc);
         const first = getFirstChoiceMessage(completion);
         if (!first) {
             spinner.stop();
             console.log(ui.error('\nResposta da API sem choices/mensagem. Tente novamente ou outro modelo.'));
             messages.pop();
+            emitCliTelemetryForTurn(modelConfig, usageAcc);
             return;
         }
         let message = first;
         spinner.stop();
-        const drained = await drainToolCalls(client, modelId, messages, toolsList, message, spinner, sessionFileCtx);
+        const drained = await drainToolCalls(client, modelId, messages, toolsList, message, spinner, sessionFileCtx, usageAcc);
         message = drained.message;
         let writeFileExecutedThisTurn = drained.writeFileExecuted;
         let anyToolExecutedThisTurn = drained.anyToolExecuted;
@@ -796,7 +872,7 @@ async function processLLMResponse(client, modelId, messages, toolsList, sessionF
             let recoveryHint = '[Pokt — recuperação] A última resposta veio vazia. Responda em português. Use tool_calls. Nunca devolva corpo vazio. ';
             if (isModificationRequest) {
                 recoveryHint +=
-                    'O usuário pediu modificação em projeto existente: chame list_files para ver arquivos, read_file no arquivo relevante, depois search_replace ou write_file no MESMO caminho. NÃO crie projeto novo. ';
+                    'O usuário pediu modificação em projeto existente: chame list_files para ver arquivos, read_file no arquivo relevante, depois search_replace ou write_file no MESMO caminho. NÃO crie projeto novo. Para conflito Next.js app/pages: delete_directory("app"). ';
             }
             recoveryHint +=
                 'Para bancos PostgreSQL: mcp_*_run_sql com {"sql":"SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY 1;"}. ' +
@@ -805,19 +881,20 @@ async function processLLMResponse(client, modelId, messages, toolsList, sessionF
             spinner.start('Recuperando resposta vazia…');
             let recovery;
             try {
-                recovery = await createCompletionWithRetry(client, modelId, messages, toolsList, 'required');
+                recovery = await createCompletionWithRetry(client, modelId, messages, toolsList, 'required', usageAcc);
             }
             catch {
-                recovery = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto');
+                recovery = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto', usageAcc);
             }
             spinner.stop();
             const recoveryFirst = getFirstChoiceMessage(recovery);
             if (!recoveryFirst) {
                 console.log(ui.error('\nResposta da API sem choices na recuperação. Tente outro modelo.'));
                 messages.pop();
+                emitCliTelemetryForTurn(modelConfig, usageAcc);
                 return;
             }
-            const drained2 = await drainToolCalls(client, modelId, messages, toolsList, recoveryFirst, spinner, sessionFileCtx);
+            const drained2 = await drainToolCalls(client, modelId, messages, toolsList, recoveryFirst, spinner, sessionFileCtx, usageAcc);
             message = drained2.message;
             writeFileExecutedThisTurn = writeFileExecutedThisTurn || drained2.writeFileExecuted;
             anyToolExecutedThisTurn = anyToolExecutedThisTurn || drained2.anyToolExecuted;
@@ -851,6 +928,10 @@ async function processLLMResponse(client, modelId, messages, toolsList, sessionF
                 finalContent = autoDb;
             }
         }
+        // Executar blocos shell que resolvem conflito Next.js (rmdir app, etc.)
+        const shellResult = await executeShellBlocksFromContent(contentStr);
+        if (shellResult.executed)
+            contentStr = shellResult.displayContent;
         // Quando a API não executa tools, tentar aplicar blocos de código da resposta
         if (!writeFileExecutedThisTurn) {
             let result = await applyCodeBlocksFromContent(contentStr, sessionFileCtx);
@@ -859,10 +940,10 @@ async function processLLMResponse(client, modelId, messages, toolsList, sessionF
                 || (/call\s+(read_file|search_replace|write_file)/i.test(contentStr) && contentStr.length < 400);
             if (!result.applied && looksLikeToolIntentOnly) {
                 messages.push({ role: 'assistant', content: rawContent ?? contentStr });
-                const followUpSystem = `You replied as if tools would run in text only. Use tool_calls for read_file/search_replace/write_file/run_command/mcp_* when possible. Prefer search_replace for edits. If you must output a file as markdown only: mention the filename then a full \`\`\`lang\`\`\` block — never use fake shell lines like mcp_Foo_bar. Do that now for the user's last request.`;
+                const followUpSystem = `You replied as if tools would run in text only. Use tool_calls for read_file/search_replace/write_file/run_command/delete_directory/delete_file/mcp_* when possible. Prefer search_replace for edits. For Next.js app/pages conflict: call delete_directory("app"). If you must output a file as markdown only: mention the filename then a full \`\`\`lang\`\`\` block — never use fake shell lines like mcp_Foo_bar. Do that now for the user's last request.`;
                 messages.push({ role: 'system', content: followUpSystem });
                 spinner.start('Getting code...');
-                const followUp = await createCompletionWithRetry(client, modelId, messages, toolsList);
+                const followUp = await createCompletionWithRetry(client, modelId, messages, toolsList, 'auto', usageAcc);
                 spinner.stop();
                 const followUpMsg = getFirstChoiceMessage(followUp);
                 if (!followUpMsg) {
@@ -914,9 +995,11 @@ async function processLLMResponse(client, modelId, messages, toolsList, sessionF
                 messages.push({ role: 'assistant', content: '' });
             }
         }
+        emitCliTelemetryForTurn(modelConfig, usageAcc);
     }
     catch (error) {
         spinner.stop();
+        emitCliTelemetryForTurn(modelConfig, usageAcc);
         const status = getStatusCode(error);
         if (status === 429) {
             console.log(ui.error('\nLimite de taxa (429). O provedor está te limitando por volume ou quota.'));

package/dist/chat/telemetry.d.ts

@@ -0,0 +1,18 @@
+/** Envia uso (tokens, modelo, provedor) ao Pokt_CLI_Back — não bloqueia o chat; falhas são ignoradas. */
+export declare function sendCliUsageTelemetryFireAndForget(params: {
+    provider: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cost: number | null;
+}): void;
+export type ChatUsageAccumulator = {
+    prompt: number;
+    completion: number;
+    cost: number | null;
+};
+export declare function emptyUsageAccumulator(): ChatUsageAccumulator;
+export declare function mergeCompletionUsage(acc: ChatUsageAccumulator, completion: {
+    usage?: unknown;
+}): void;

package/dist/chat/telemetry.js

@@ -0,0 +1,62 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { getOrCreateCliInstallId, getCliHostLabel, getPoktApiBaseUrl, getPoktToken, isCliTelemetryDisabled, } from '../config.js';
+let cachedVersion = null;
+function readCliVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const base = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(base, '..', '..', 'package.json');
+        const raw = readFileSync(pkgPath, 'utf8');
+        const j = JSON.parse(raw);
+        cachedVersion = typeof j.version === 'string' ? j.version.slice(0, 32) : 'unknown';
+    }
+    catch {
+        cachedVersion = 'unknown';
+    }
+    return cachedVersion;
+}
+/** Envia uso (tokens, modelo, provedor) ao Pokt_CLI_Back — não bloqueia o chat; falhas são ignoradas. */
+export function sendCliUsageTelemetryFireAndForget(params) {
+    if (isCliTelemetryDisabled())
+        return;
+    if (params.provider === 'controller')
+        return;
+    const pt = params.promptTokens + params.completionTokens;
+    if (pt <= 0 && params.totalTokens <= 0)
+        return;
+    const base = getPoktApiBaseUrl();
+    const url = `${base}/api/v1/telemetry/usage`;
+    const token = getPoktToken();
+    const headers = { 'Content-Type': 'application/json' };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const total = params.totalTokens > 0 ? params.totalTokens : params.promptTokens + params.completionTokens;
+    const body = JSON.stringify({
+        installId: getOrCreateCliInstallId(),
+        hostLabel: getCliHostLabel(),
+        provider: params.provider,
+        model: params.model,
+        prompt_tokens: params.promptTokens,
+        completion_tokens: params.completionTokens,
+        total_tokens: total,
+        cost: params.cost,
+        cli_version: readCliVersion(),
+    });
+    void fetch(url, { method: 'POST', headers, body }).catch(() => { });
+}
+export function emptyUsageAccumulator() {
+    return { prompt: 0, completion: 0, cost: null };
+}
+export function mergeCompletionUsage(acc, completion) {
+    const u = completion.usage;
+    if (!u)
+        return;
+    acc.prompt += Number(u.prompt_tokens) || 0;
+    acc.completion += Number(u.completion_tokens) || 0;
+    if (u.cost != null && !Number.isNaN(Number(u.cost))) {
+        acc.cost = (acc.cost ?? 0) + Number(u.cost);
+    }
+}

package/dist/chat/tools.js

@@ -247,6 +247,34 @@ export const tools = [
                 }
             }
         }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Deletes a single file. Use for removing files that cause conflicts (e.g. app/page.tsx in Next.js).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the file to delete' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_directory',
+            description: 'Deletes a directory and all its contents recursively. Use to resolve Next.js app/pages conflict: delete_directory("app") removes the app folder so only pages/ remains. Cross-platform, no shell needed.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the directory to delete (e.g. "app" for Next.js app folder)' }
+                },
+                required: ['path']
+            }
+        }
     }
 ];
 export async function executeTool(name, argsStr) {
@@ -331,6 +359,45 @@ export async function executeTool(name, argsStr) {
             walk(root);
             return files.join('\n') || 'No files found.';
         }
+        /** Garante que o caminho resolvido está dentro do cwd (evita path traversal) */
+        function ensureWithinCwd(resolved) {
+            const cwd = process.cwd();
+            const normCwd = path.resolve(cwd);
+            const normResolved = path.resolve(resolved);
+            return normResolved.startsWith(normCwd + path.sep) || normResolved === normCwd;
+        }
+        if (name === 'delete_file') {
+            const filePath = path.resolve(process.cwd(), args.path);
+            if (!ensureWithinCwd(filePath)) {
+                return `Error: Path "${args.path}" is outside the project directory. Refused for safety.`;
+            }
+            if (!fs.existsSync(filePath)) {
+                return `Error: File not found: ${args.path}`;
+            }
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                return `Error: ${args.path} is a directory. Use delete_directory to remove it.`;
+            }
+            fs.unlinkSync(filePath);
+            console.log(chalk.blue.bold(`\n🗑️ Removido: ${path.relative(process.cwd(), filePath)}\n`));
+            return `Successfully deleted ${args.path}`;
+        }
+        if (name === 'delete_directory') {
+            const dirPath = path.resolve(process.cwd(), args.path);
+            if (!ensureWithinCwd(dirPath)) {
+                return `Error: Path "${args.path}" is outside the project directory. Refused for safety.`;
+            }
+            if (!fs.existsSync(dirPath)) {
+                return `Error: Directory not found: ${args.path}`;
+            }
+            const stat = fs.statSync(dirPath);
+            if (!stat.isDirectory()) {
+                return `Error: ${args.path} is not a directory. Use delete_file to remove it.`;
+            }
+            fs.rmSync(dirPath, { recursive: true });
+            console.log(chalk.blue.bold(`\n🗑️ Pasta removida: ${path.relative(process.cwd(), dirPath)}\n`));
+            return `Successfully deleted directory ${args.path}`;
+        }
         return `Unknown tool: ${name}`;
     }
     catch (error) {

package/dist/config.d.ts

@@ -41,6 +41,8 @@ interface AppConfig {
     /** Só compra de token / checkout — Vercel */
     tokenPurchaseBaseUrl: string;
     poktToken: string;
+    /** ID estável por instalação (telemetria de uso no Back) */
+    cliInstallId: string;
     registeredModels: ModelConfig[];
     activeModel: ModelConfig | null;
     mcpServers: McpServerConfig[];
@@ -54,6 +56,7 @@ export declare const env: {
     readonly ollamaBaseUrl: readonly ["OLLAMA_BASE_URL"];
     readonly ollamaCloudApiKey: readonly ["OLLAMA_CLOUD_API_KEY"];
     readonly poktToken: readonly ["POKT_TOKEN"];
+    readonly disableTelemetry: readonly ["POKT_DISABLE_TELEMETRY"];
     readonly poktApiBaseUrl: readonly ["POKT_API_BASE_URL"];
     /** Painel e URLs gerais (Railway) */
     readonly proPortalUrl: readonly ["POKT_PRO_PORTAL_URL", "POKT_CONTROLLER_PORTAL_URL"];
@@ -67,6 +70,11 @@ export declare function getGeminiApiKey(): string;
 export declare function getOllamaBaseUrl(): string;
 export declare function getOllamaCloudApiKey(): string;
 export declare function getPoktToken(): string;
+/** UUID persistente por máquina/instalação (identifica uso no painel quando não há token Pokt). */
+export declare function getOrCreateCliInstallId(): string;
+/** Nome do PC (sanitizado) para exibição no log de uso. */
+export declare function getCliHostLabel(): string;
+export declare function isCliTelemetryDisabled(): boolean;
 /** Base da API só para provider `controller` (Bearer Pokt). OpenAI direto usa outro ramo no getClient. */
 export declare function getPoktApiBaseUrl(): string;
 /** Painel e links gerais (Railway), exceto compra de token — ver getTokenPurchaseUrl(). */

package/dist/config.js

@@ -1,4 +1,6 @@
 import Conf from 'conf';
+import { randomUUID } from 'crypto';
+import os from 'os';
 export const PROVIDER_LABELS = {
     controller: 'Pokt API (Controller)',
     openai: 'OpenAI',
@@ -41,6 +43,7 @@ export const config = new Conf({
         poktApiBaseUrl: DEFAULT_POKT_SERVICE_BASE_URL,
         tokenPurchaseBaseUrl: DEFAULT_TOKEN_PURCHASE_BASE_URL,
         poktToken: '',
+        cliInstallId: '',
         registeredModels: [
             { provider: 'controller', id: 'default' },
             { provider: 'openai', id: 'gpt-4o-mini' },
@@ -70,6 +73,7 @@ export const env = {
     ollamaBaseUrl: ['OLLAMA_BASE_URL'],
     ollamaCloudApiKey: ['OLLAMA_CLOUD_API_KEY'],
     poktToken: ['POKT_TOKEN'],
+    disableTelemetry: ['POKT_DISABLE_TELEMETRY'],
     poktApiBaseUrl: ['POKT_API_BASE_URL'],
     /** Painel e URLs gerais (Railway) */
     proPortalUrl: ['POKT_PRO_PORTAL_URL', 'POKT_CONTROLLER_PORTAL_URL'],
@@ -113,6 +117,29 @@ export function getOllamaCloudApiKey() {
 export function getPoktToken() {
     return readEnvFirst(env.poktToken) || config.get('poktToken') || '';
 }
+/** UUID persistente por máquina/instalação (identifica uso no painel quando não há token Pokt). */
+export function getOrCreateCliInstallId() {
+    let id = config.get('cliInstallId');
+    if (typeof id !== 'string' || !/^[0-9a-f-]{36}$/i.test(id)) {
+        id = randomUUID();
+        config.set('cliInstallId', id);
+    }
+    return id;
+}
+/** Nome do PC (sanitizado) para exibição no log de uso. */
+export function getCliHostLabel() {
+    try {
+        const h = os.hostname().replace(/[^\w.-]+/g, '_').slice(0, 120);
+        return h || 'PC';
+    }
+    catch {
+        return 'PC';
+    }
+}
+export function isCliTelemetryDisabled() {
+    const v = readEnvFirst(env.disableTelemetry);
+    return v === '1' || v.toLowerCase() === 'true' || v.toLowerCase() === 'yes';
+}
 /** Base da API só para provider `controller` (Bearer Pokt). OpenAI direto usa outro ramo no getClient. */
 export function getPoktApiBaseUrl() {
     const fromEnv = readEnvFirst(env.poktApiBaseUrl);

package/dist/mcp/client.js

@@ -77,7 +77,7 @@ async function connectMcpStdio(serverConfig) {
         args: serverConfig.args ?? [],
         env: mergeProcessEnv(serverConfig.env),
     });
-    const client = new Client({ name: 'pokt-cli', version: '1.0.8' });
+    const client = new Client({ name: 'pokt-cli', version: '1.0.12' });
     await client.connect(transport);
     const tools = await buildToolsFromClient(serverConfig, client);
     return pushSession(serverConfig, client, tools, transport);
@@ -112,7 +112,7 @@ async function connectMcpHttp(serverConfig) {
             }
             return makeStreamableTransport(url, { authProvider, headers });
         };
-        const client = new Client({ name: 'pokt-cli', version: '1.0.8' });
+        const client = new Client({ name: 'pokt-cli', version: '1.0.12' });
         let transport = await makeTransport();
         const cleanupCb = async () => {
             try {
@@ -151,7 +151,7 @@ async function connectMcpHttp(serverConfig) {
     const transport = useSse
         ? await makeSseTransport(url, { headers })
         : await makeStreamableTransport(url, { headers });
-    const client = new Client({ name: 'pokt-cli', version: '1.0.8' });
+    const client = new Client({ name: 'pokt-cli', version: '1.0.12' });
     await client.connect(transport);
     const tools = await buildToolsFromClient(serverConfig, client);
     return pushSession(serverConfig, client, tools, transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pokt-cli",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Vibe Coding AI CLI for OpenRouter and Ollama",
   "main": "./dist/bin/pokt.js",
   "type": "module",