jaylog-mcp 0.1.1 → 0.1.2

package/README.md

@@ -6,21 +6,40 @@ agendamento de tarefas, contra a API do Jaylog.
 
 > **Escopo inicial:** apenas ferramentas de leitura (GET). Nenhuma tool cria, altera ou apaga dados.
 
+## Sumário
+
+- [Instalação](#instalação)
+- [Autenticação](#autenticação)
+- [Configuração](#configuração)
+- [Desenvolvimento](#desenvolvimento)
+- [Tools](#tools)
+  - [Logs, métricas e recursos](#logs-métricas-e-recursos)
+  - [Serviços](#serviços)
+  - [Agendamento de tarefas](#agendamento-de-tarefas)
+  - [Usuários chave](#usuários-chave)
+  - [Erros / Issues](#erros--issues)
+- [Skills](#skills)
+- [Estrutura](#estrutura)
+- [Debugging](#debugging)
+
 ## Instalação
 
 Requer Node.js 18+. Não precisa instalar nada: o `npx` baixa e executa o pacote.
 
 ```bash
-export JAYLOG_API_BASE_URL=https://sua-api-jaylog   # URL da API
-npx -y jaylog-mcp-server login                       # abre o navegador para autenticar
+export JAYLOG_URL=https://seu-app-jaylog   # URL do app web do Jaylog
+npx -y jaylog-mcp login                     # abre o navegador para autenticar
 ```
 
+> Uma única URL basta: o MCP chama a API pelo proxy do app web (`<JAYLOG_URL>/proxy/*`). Para
+> apontar a API diretamente (ex.: desenvolvimento local), veja [Configuração](#configuração).
+
 Depois do login, registre o servidor no seu cliente MCP.
 
 **Claude Code:**
 
 ```bash
-claude mcp add jaylog --env JAYLOG_API_BASE_URL=https://sua-api-jaylog -- npx -y jaylog-mcp-server
+claude mcp add jaylog --env JAYLOG_URL=https://seu-app-jaylog -- npx -y jaylog-mcp
 ```
 
 **Outros clientes (Claude Desktop, Cursor etc.):**
@@ -30,9 +49,9 @@ claude mcp add jaylog --env JAYLOG_API_BASE_URL=https://sua-api-jaylog -- npx -y
   "mcpServers": {
     "jaylog": {
       "command": "npx",
-      "args": ["-y", "jaylog-mcp-server"],
+      "args": ["-y", "jaylog-mcp"],
       "env": {
-        "JAYLOG_API_BASE_URL": "https://sua-api-jaylog"
+        "JAYLOG_URL": "https://seu-app-jaylog"
       }
     }
   }
@@ -44,7 +63,7 @@ claude mcp add jaylog --env JAYLOG_API_BASE_URL=https://sua-api-jaylog -- npx -y
 
 ## Autenticação
 
-`npx -y jaylog-mcp-server login` abre o navegador numa tela de consentimento do app web do Jaylog
+`npx -y jaylog-mcp login` abre o navegador numa tela de consentimento do app web do Jaylog
 (`/mcp/authorize`) — o mesmo padrão do `claude login`/`gh auth login`: o MCP sobe um servidor HTTP
 local efêmero (`127.0.0.1:<porta>`), o navegador confirma sua identidade (sessão já logada ou
 login + 2FA) e, ao clicar em "Permitir", o Jaylog emite um token pessoal que volta pro MCP via esse
@@ -57,16 +76,17 @@ callback local.
 - `logout` apenas apaga a credencial local; para invalidar o token de fato, revogue-o no app.
 
 ```bash
-npx -y jaylog-mcp-server login     # autentica (abre o navegador)
-npx -y jaylog-mcp-server logout    # remove a credencial local
+npx -y jaylog-mcp login     # autentica (abre o navegador)
+npx -y jaylog-mcp logout    # remove a credencial local
 ```
 
 ## Configuração
 
 | Variável | Descrição |
 |---|---|
-| `JAYLOG_API_BASE_URL` | URL base da API do Jaylog (ex: `http://localhost:3000`) |
-| `JAYLOG_FRONTEND_URL` | URL do app web do Jaylog, usada só pelo `login` para abrir `/mcp/authorize`. Se omitida, cai para `JAYLOG_API_BASE_URL` (ok quando os dois estão atrás do mesmo domínio). |
+| `JAYLOG_URL` | URL do app web do Jaylog. É a única variável necessária: o `login` abre `<JAYLOG_URL>/mcp/authorize` e as tools chamam a API em `<JAYLOG_URL>/proxy/*`. |
+| `JAYLOG_API_BASE_URL` | Override opcional: URL base da API chamada diretamente, sem passar pelo proxy (ex: `http://localhost:3000`). Quando definida, tem prioridade sobre `JAYLOG_URL` nas chamadas à API. |
+| `JAYLOG_FRONTEND_URL` | Override opcional: URL do app web usada só pelo `login`. Útil em desenvolvimento local, onde a API e o app web rodam em portas diferentes. Se omitida, cai para `JAYLOG_URL`. |
 | `JAYLOG_API_TOKEN` | Override explícito: se definida, tem prioridade sobre a credencial salva pelo `login`. Útil para CI/scripting. Qualquer perfil (guest, standard, staff, admin) funciona — cada tool exige o perfil mínimo que a rota correspondente já exige na API. |
 
 ## Desenvolvimento
@@ -75,7 +95,7 @@ Para rodar a partir do código-fonte (requer [Bun](https://bun.sh)):
 
 ```bash
 bun install
-cp .env.example .env   # edite com a URL da API
+cp .env.example .env   # edite com as URLs do app web/API
 bun run login          # autentica (abre o navegador)
 bun run start          # roda direto com Bun
 bun run dev            # com --watch
@@ -97,7 +117,9 @@ bun run build          # compila para dist/ (uso via Node/bin)
 
 ### Serviços
 
-- **`list-services`**: lista serviços (aplicações/bots que enviam logs), com dono, empresa e setor resolvidos.
+- **`list-services`**: lista serviços (aplicações/bots que enviam logs), com empresa e setor resolvidos. O `owner` vem como ID de usuário.
+- **`list-favorite-services`**: serviços favoritados pelo usuário autenticado (os favoritos são sempre do usuário logado no MCP).
+- **`search-services-by-owner`**: busca serviços pelo nome e/ou e-mail do dono (substring, sem diferenciar maiúsculas), retornando um item por usuário encontrado com seus serviços. Requer perfil `standard` ou superior.
 
 ### Agendamento de tarefas
 
@@ -113,9 +135,33 @@ bun run build          # compila para dist/ (uso via Node/bin)
 - **`list-issues`**: issues (bugs/erros) abertos manualmente contra um serviço, com autor e responsável resolvidos.
 - **`get-issue`**: uma issue específica por ID.
 
+## Skills
+
+O repositório inclui skills (pasta `skills/`) com fluxos prontos que usam as tools acima. Elas
+seguem o padrão do [skills.sh](https://skills.sh) e funcionam em Claude Code, Cursor e outros
+agentes compatíveis. Requerem o MCP configurado e autenticado.
+
+```bash
+npx skills add Gpocas/jaylog-mcp                                   # instala todas
+npx skills add Gpocas/jaylog-mcp --skill jaylog-incident-report    # instala uma
+npx skills add Gpocas/jaylog-mcp -g                                # global (~/.claude/skills)
+```
+
+- **`jaylog-incident-report`**: relatório em markdown de incidentes (erros nos logs, serviços
+  parados, agendamentos não cumpridos e issues). Começa com uma entrevista de múltipla escolha
+  para personalizar escopo (todos, favoritos ou serviços de um owner), categorias, período
+  (padrão: dia anterior) e extras (contatos, mensagens completas, só críticos). Salva em
+  `./reports/incidentes-AAAA-MM-DD.md`.
+- **`jaylog-fix-service-errors`**: levanta os erros recentes de um serviço (escolhido por nome,
+  owner ou entre os favoritos), localiza o código responsável na pasta atual e **propõe**
+  correções (não edita arquivos).
+
 ## Estrutura
 
 ```
+skills/
+├── jaylog-incident-report/SKILL.md
+└── jaylog-fix-service-errors/SKILL.md
 src/
 ├── index.ts        → bootstrap do McpServer (stdio)
 ├── api.ts          → fetch autenticado contra a API do Jaylog
@@ -132,5 +178,5 @@ src/
 Como o MCP roda via stdio, use o [MCP Inspector](https://github.com/modelcontextprotocol/inspector):
 
 ```bash
-npx @modelcontextprotocol/inspector npx -y jaylog-mcp-server
+npx @modelcontextprotocol/inspector npx -y jaylog-mcp
 ```

package/dist/api.js

@@ -1,11 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveApiBaseUrl = resolveApiBaseUrl;
 exports.buildUrl = buildUrl;
 exports.fetchJSON = fetchJSON;
 const credentials_1 = require("./credentials");
-const config = {
-    baseUrl: process.env.JAYLOG_API_BASE_URL
-};
+const trimSlashes = (value) => value.replace(/\/+$/, '');
+/**
+ * Where API calls go. `JAYLOG_API_BASE_URL` wins when set (local dev, where the
+ * backend and the web app run on different ports, or a deployment that exposes
+ * the API directly). Otherwise the single `JAYLOG_URL` is the web app's address
+ * and the API is reached through its `/proxy/*` route, which forwards to the
+ * backend — that is what lets users configure one URL instead of two.
+ */
+function resolveApiBaseUrl() {
+    const apiBase = process.env.JAYLOG_API_BASE_URL;
+    if (apiBase)
+        return trimSlashes(apiBase);
+    const appUrl = process.env.JAYLOG_URL;
+    if (appUrl)
+        return `${trimSlashes(appUrl)}/proxy`;
+    return undefined;
+}
 /**
  * Resolution order: `JAYLOG_API_TOKEN` env var (explicit override, handy for CI
  * or scripting) first, then the credential saved by `login` — a personal,
@@ -23,10 +38,13 @@ async function getAuthHeaders() {
     return { Authorization: `Bearer ${stored.token}` };
 }
 function buildUrl(path, qs = {}) {
-    if (!config.baseUrl) {
-        throw new Error('JAYLOG_API_BASE_URL is not set. Configure it (and JAYLOG_API_TOKEN) in the environment.');
+    const baseUrl = resolveApiBaseUrl();
+    if (!baseUrl) {
+        throw new Error('JAYLOG_URL is not set. Set it to the Jaylog web app URL (or JAYLOG_API_BASE_URL to call the API directly).');
     }
-    const url = new URL(path, config.baseUrl);
+    // `new URL('/x', 'https://host/proxy')` drops `/proxy`, so keep the base's
+    // path by resolving a relative path against a base that ends in `/`.
+    const url = new URL(path.replace(/^\/+/, ''), `${baseUrl}/`);
     for (const [k, v] of Object.entries(qs)) {
         if (v !== undefined && v !== null)
             url.searchParams.set(k, String(v));

package/dist/auth/login.js

@@ -30,9 +30,9 @@ p { color: #a1a1aa; font-size: 0.9rem; }
  * freshly minted personal token back to a one-shot local server, store it.
  */
 async function login() {
-    const frontendUrl = process.env.JAYLOG_FRONTEND_URL || process.env.JAYLOG_API_BASE_URL;
+    const frontendUrl = process.env.JAYLOG_FRONTEND_URL || process.env.JAYLOG_URL || process.env.JAYLOG_API_BASE_URL;
     if (!frontendUrl) {
-        throw new Error('Set JAYLOG_FRONTEND_URL (or JAYLOG_API_BASE_URL) before running login.');
+        throw new Error('Set JAYLOG_URL (the Jaylog web app URL) before running login.');
     }
     const state = (0, node_crypto_1.randomBytes)(16).toString('hex');
     const result = await new Promise((resolve, reject) => {

package/dist/tools/services.js

@@ -15,8 +15,9 @@ function asText(data) {
 }
 function registerServiceTools(server) {
     server.registerTool('list-services', {
-        description: 'List registered services (the applications/bots that send logs), with their owner, company and ' +
-            'sector already resolved.',
+        description: 'List registered services (the applications/bots that send logs), with company and sector names ' +
+            'already resolved. `owner` is a user ID; use `search-services-by-owner` to search by the ' +
+            'owner\'s name or email instead.',
         inputSchema: {
             name: zod_1.z.string().optional().describe('Substring match against the service name'),
             owner: zod_1.z.string().uuid().optional().describe('User ID of the service owner'),
@@ -24,4 +25,40 @@ function registerServiceTools(server) {
             sector_id: zod_1.z.string().uuid().optional().describe('Restrict to a sector')
         }
     }, async (params) => asText(await (0, api_1.fetchJSON)('/service/list', params)));
+    server.registerTool('list-favorite-services', {
+        description: 'List the services the authenticated user has marked as favorites, with the same fields as ' +
+            '`list-services` (company and sector names resolved). Favorites belong to the user the MCP is ' +
+            'logged in as; there is no way to read someone else\'s.'
+    }, async () => {
+        const favorites = await (0, api_1.fetchJSON)('/favorites/list');
+        if (favorites.length === 0)
+            return asText([]);
+        // The favorites route only returns IDs, so resolve them against the service list.
+        const favoriteIds = new Set(favorites.map(favorite => favorite.service_id));
+        const services = await (0, api_1.fetchJSON)('/service/list');
+        return asText(services.filter(service => favoriteIds.has(service.id)));
+    });
+    server.registerTool('search-services-by-owner', {
+        description: 'Find the services owned by a person, searching by the owner\'s name and/or email (case-insensitive ' +
+            'substring match). Returns one entry per matching user with that user\'s services. A user that ' +
+            'matches but owns nothing is returned with an empty list. Use `list-services` with `owner` ' +
+            'instead when you already have the owner\'s user ID.',
+        inputSchema: {
+            name: zod_1.z.string().min(1).optional().describe('Substring match against the owner\'s name'),
+            email: zod_1.z.string().min(1).optional().describe('Substring match against the owner\'s email')
+        }
+    }, async ({ name, email }) => {
+        if (!name && !email) {
+            throw new Error('Provide at least one of `name` or `email`.');
+        }
+        const users = await (0, api_1.fetchJSON)('/user/list', { name, email });
+        if (users.length === 0)
+            return asText([]);
+        // One service request filtered client-side beats one request per matching user.
+        const services = await (0, api_1.fetchJSON)('/service/list');
+        return asText(users.map(user => ({
+            owner: { id: user.id, name: user.name, email: user.email, is_active: user.is_active },
+            services: services.filter(service => service.owner === user.id)
+        })));
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaylog-mcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Model Context Protocol server for Jaylog observability (logs, metrics, services, schedules)",
   "bin": {
     "jaylog-mcp-server": "dist/index.js"