jaylog-mcp 0.0.0-stage → 0.1.2

package/README.md

@@ -1,3 +1,182 @@
-# Temporary Holding Version
+# Jaylog MCP Server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Servidor [Model Context Protocol](https://github.com/modelcontextprotocol) para observabilidade do
+ecossistema Jaylog: consulta de logs, métricas de recursos, erros, usuários chave, serviços e
+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_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_URL=https://seu-app-jaylog -- npx -y jaylog-mcp
+```
+
+**Outros clientes (Claude Desktop, Cursor etc.):**
+
+```json
+{
+  "mcpServers": {
+    "jaylog": {
+      "command": "npx",
+      "args": ["-y", "jaylog-mcp"],
+      "env": {
+        "JAYLOG_URL": "https://seu-app-jaylog"
+      }
+    }
+  }
+}
+```
+
+> Rodando via `npx`/Node, o arquivo `.env` **não** é lido. Defina as variáveis no shell ou no
+> bloco `env` do cliente MCP, como acima.
+
+## Autenticação
+
+`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
+callback local.
+
+- O token é salvo em `~/.config/jaylog-mcp/credentials.json` (permissão `600`).
+- Expira em 15 dias, renovado automaticamente a cada uso — não expira por ficar o MCP parado, só por
+  ficar **sem uso**.
+- Pode ser revogado a qualquer momento na tela "Tokens MCP" do app, sem precisar reinstalar nada.
+- `logout` apenas apaga a credencial local; para invalidar o token de fato, revogue-o no app.
+
+```bash
+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_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
+
+Para rodar a partir do código-fonte (requer [Bun](https://bun.sh)):
+
+```bash
+bun install
+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
+bun run build          # compila para dist/ (uso via Node/bin)
+```
+
+## Tools
+
+### Logs, métricas e recursos
+
+- **`list-logs`**: lista logs com filtros (serviço, hostname, username, ipv4, nível, mensagem, intervalo de tempo).
+- **`get-latest-logs`**: último log de cada instância em execução, com dados de liveness (execução ativa, última atividade, múltiplas execuções vivas).
+- **`get-log`**: um log específico por ID, com a mensagem completa.
+- **`get-error-histogram`**: histograma de contagem de logs/erros por período, a partir dos logs brutos (janela limitada pela retenção).
+- **`get-error-history`**: histórico diário consolidado de erros por serviço (janela maior que o histograma).
+- **`get-host-metrics`**: uso de CPU/memória/disco/I/O de uma instância ao longo do tempo, com os limites de hardware da máquina.
+- **`list-hosts`**: instâncias registradas (ambiente, versão do Python/jaylog, estado do git, venv).
+- **`get-host-stats`**: contagem agregada por modo de execução, versão do Python/jaylog, tipo de venv e branch do git.
+
+### Serviços
+
+- **`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
+
+- **`list-service-schedules`**: horários agendados dos serviços — manuais ou sincronizados do Task Scheduler do Windows (somente leitura nesse caso).
+
+### Usuários chave
+
+- **`list-key-users`**: usuários chave (contatos de negócio ligados a serviços — não são usuários de login do sistema).
+- **`list-service-key-users`**: vínculos entre serviços e seus usuários chave.
+
+### Erros / Issues
+
+- **`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
+└── tools/
+    ├── logs.ts      → logs, métricas, recursos, hosts
+    ├── services.ts  → serviços
+    ├── schedules.ts → agendamento de tarefas
+    ├── keyUsers.ts  → usuários chave
+    └── issues.ts    → erros/issues
+```
+
+## Debugging
+
+Como o MCP roda via stdio, use o [MCP Inspector](https://github.com/modelcontextprotocol/inspector):
+
+```bash
+npx @modelcontextprotocol/inspector npx -y jaylog-mcp
+```

package/dist/api.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveApiBaseUrl = resolveApiBaseUrl;
+exports.buildUrl = buildUrl;
+exports.fetchJSON = fetchJSON;
+const credentials_1 = require("./credentials");
+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,
+ * 15-day sliding-expiration token minted via the browser consent flow at
+ * `${JAYLOG_FRONTEND_URL}/mcp/authorize`. Re-read on every call (not cached)
+ * so a `logout`/`login` in another terminal takes effect without a restart.
+ */
+async function getAuthHeaders() {
+    const envToken = process.env.JAYLOG_API_TOKEN;
+    if (envToken)
+        return { Authorization: `Bearer ${envToken}` };
+    const stored = await (0, credentials_1.readCredentials)();
+    if (!stored)
+        return {};
+    return { Authorization: `Bearer ${stored.token}` };
+}
+function buildUrl(path, qs = {}) {
+    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).');
+    }
+    // `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));
+    }
+    return url.toString();
+}
+async function fetchJSON(path, qs = {}) {
+    const url = buildUrl(path, qs);
+    const headers = await getAuthHeaders();
+    if (!headers.Authorization) {
+        throw new Error('Not authenticated. Run `bun run login` (or set JAYLOG_API_TOKEN) before using jaylog-mcp.');
+    }
+    const resp = await fetch(url, { headers });
+    if (!resp.ok) {
+        const body = await resp.text().catch(() => '');
+        throw new Error(`Jaylog API error [${resp.status}] ${resp.statusText}${body ? `: ${body}` : ''}`);
+    }
+    return (await resp.json());
+}

package/dist/auth/login.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
+const node_os_1 = require("node:os");
+const colors_1 = require("../cli/colors");
+const credentials_1 = require("../credentials");
+const open_1 = require("./open");
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+function page(message) {
+    return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Jaylog MCP</title>
+<style>
+body { font-family: system-ui, sans-serif; background: #18181b; color: #e4e4e7; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+main { text-align: center; max-width: 28rem; padding: 0 1.5rem; }
+h1 { font-size: 1.1rem; font-weight: 600; }
+p { color: #a1a1aa; font-size: 0.9rem; }
+</style>
+</head>
+<body><main><h1>${message}</h1><p>Você pode fechar esta aba e voltar pro terminal.</p></main></body>
+</html>`;
+}
+/**
+ * Loopback browser login (RFC 8252), the same shape `gh auth login` and
+ * `claude login` use: open the frontend's consent page, wait for it to hand a
+ * 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_URL || process.env.JAYLOG_API_BASE_URL;
+    if (!frontendUrl) {
+        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) => {
+        let settled = false;
+        const done = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            fn();
+        };
+        const server = (0, node_http_1.createServer)((req, res) => {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            if (url.pathname !== '/callback') {
+                res.writeHead(404).end();
+                return;
+            }
+            const receivedState = url.searchParams.get('state');
+            const token = url.searchParams.get('token');
+            const expiresAt = url.searchParams.get('expires_at') ?? undefined;
+            if (receivedState !== state || !token) {
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(page('Falha na autorização: parâmetros inválidos.'));
+                done(() => reject(new Error('Invalid callback: state mismatch or missing token.')));
+                server.close();
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(page('Autenticado com sucesso!'));
+            done(() => resolve({ token, expiresAt }));
+            server.close();
+        });
+        const timeout = setTimeout(() => {
+            done(() => reject(new Error('Login timed out after 5 minutes. Run `login` again.')));
+            server.close();
+        }, CALLBACK_TIMEOUT_MS);
+        timeout.unref();
+        server.on('error', error => done(() => reject(error)));
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                done(() => reject(new Error('Failed to start local callback server.')));
+                return;
+            }
+            const authorizeUrl = new URL('/mcp/authorize', frontendUrl);
+            authorizeUrl.searchParams.set('redirect_uri', `http://127.0.0.1:${address.port}/callback`);
+            authorizeUrl.searchParams.set('state', state);
+            authorizeUrl.searchParams.set('client_name', `Jaylog MCP (${(0, node_os_1.hostname)()})`);
+            console.error(colors_1.colors.white('Opening browser to authorize:'));
+            console.error(`  ${colors_1.colors.cyan(authorizeUrl.toString())}\n`);
+            console.error(colors_1.colors.dim('If it does not open automatically, copy the link above into your browser.'));
+            (0, open_1.openBrowser)(authorizeUrl.toString());
+        });
+    });
+    await (0, credentials_1.writeCredentials)({
+        token: result.token,
+        expiresAt: result.expiresAt,
+        obtainedAt: new Date().toISOString()
+    });
+    console.error(colors_1.colors.boldGreen(`Logged in. Credential saved${result.expiresAt ? ` (valid until ${result.expiresAt})` : ''}.`));
+}

package/dist/auth/logout.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = logout;
+const colors_1 = require("../cli/colors");
+const credentials_1 = require("../credentials");
+async function logout() {
+    const cleared = await (0, credentials_1.clearCredentials)();
+    console.error(cleared
+        ? colors_1.colors.boldGreen('Logged out. Local credential removed.') +
+            '\n' +
+            colors_1.colors.dim('The token itself still works until it expires or is revoked from "Tokens MCP" in the app.')
+        : colors_1.colors.yellow('No stored credential found.'));
+}

package/dist/auth/open.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = openBrowser;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Best-effort browser launch. The caller always prints the URL too, since this
+ * silently does nothing useful over a headless SSH session or inside WSL
+ * without `wslview`/`xdg-open` wired to the Windows browser.
+ */
+function openBrowser(url) {
+    try {
+        const platform = process.platform;
+        const child = platform === 'darwin'
+            ? (0, node_child_process_1.spawn)('open', [url], { stdio: 'ignore', detached: true })
+            : platform === 'win32'
+                ? (0, node_child_process_1.spawn)('cmd', ['/c', 'start', '""', url], { stdio: 'ignore', detached: true })
+                : (0, node_child_process_1.spawn)('xdg-open', [url], { stdio: 'ignore', detached: true });
+        // Without this, a missing binary (e.g. no `xdg-open` in a bare WSL image)
+        // emits an unhandled 'error' event on the child process and crashes the
+        // CLI — the printed URL is the real fallback, so just swallow it.
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // Ignored: the printed URL is the real fallback.
+    }
+}

package/dist/cli/colors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+// Bun's `console.error` wraps everything written to it in ANSI red by
+// default (confirmed: `bun -e "console.error('x')"` emits `\x1b[31m`) — and
+// stdout is reserved for the MCP JSON-RPC protocol, so stderr is the only
+// place these messages can go. Each call below resets *before* applying its
+// own code, which is required, not just tidy: a color code (e.g. white/cyan)
+// replaces Bun's red, but `dim` alone only adds faintness to whatever
+// foreground is already active, so without the leading reset it would render
+// as dim *red* instead of a neutral dim. Disabled outside a TTY
+// (piped/redirected output) and when NO_COLOR is set, per https://no-color.org.
+const supportsColor = !!process.stderr.isTTY && !process.env.NO_COLOR;
+function wrap(code) {
+    return text => (supportsColor ? `\x1b[0m\x1b[${code}m${text}\x1b[0m` : text);
+}
+// `boldGreen`/`boldRed` are single combined codes, not `bold(green(x))`: each
+// `wrap()` call resets first (see above), so nesting two of them would have
+// the inner reset wipe out the outer's bold — two SGR codes in one escape
+// sequence is the only way to actually get both at once.
+exports.colors = {
+    white: wrap('37'),
+    dim: wrap('2'),
+    cyan: wrap('36'),
+    green: wrap('32'),
+    yellow: wrap('33'),
+    red: wrap('31'),
+    boldGreen: wrap('1;32'),
+    boldRed: wrap('1;31')
+};

package/dist/credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCredentials = readCredentials;
+exports.writeCredentials = writeCredentials;
+exports.clearCredentials = clearCredentials;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function credentialsDir() {
+    const base = process.env.XDG_CONFIG_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), '.config');
+    return (0, node_path_1.join)(base, 'jaylog-mcp');
+}
+function credentialsPath() {
+    return (0, node_path_1.join)(credentialsDir(), 'credentials.json');
+}
+async function readCredentials() {
+    try {
+        const raw = await (0, promises_1.readFile)(credentialsPath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCredentials(creds) {
+    await (0, promises_1.mkdir)(credentialsDir(), { recursive: true, mode: 0o700 });
+    await (0, promises_1.writeFile)(credentialsPath(), JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+async function clearCredentials() {
+    try {
+        await (0, promises_1.rm)(credentialsPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const login_1 = require("./auth/login");
+const logout_1 = require("./auth/logout");
+const colors_1 = require("./cli/colors");
+const issues_1 = require("./tools/issues");
+const keyUsers_1 = require("./tools/keyUsers");
+const logs_1 = require("./tools/logs");
+const schedules_1 = require("./tools/schedules");
+const services_1 = require("./tools/services");
+async function runServer() {
+    const server = new mcp_js_1.McpServer({
+        name: 'Jaylog',
+        version: '0.1.0'
+    });
+    (0, logs_1.registerLogTools)(server);
+    (0, services_1.registerServiceTools)(server);
+    (0, schedules_1.registerScheduleTools)(server);
+    (0, keyUsers_1.registerKeyUserTools)(server);
+    (0, issues_1.registerIssueTools)(server);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error(colors_1.colors.dim('Jaylog MCP Server running on stdio'));
+}
+async function main() {
+    const command = process.argv[2];
+    if (command === 'login')
+        return (0, login_1.login)();
+    if (command === 'logout')
+        return (0, logout_1.logout)();
+    return runServer();
+}
+main().catch(error => {
+    console.error(colors_1.colors.boldRed(`Fatal error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+});

package/dist/tools/issues.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerIssueTools = registerIssueTools;
+const zod_1 = require("zod");
+const api_1 = require("../api");
+const issueStates = ['open', 'working', 'merged', 'closed'];
+function asText(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(data, null, 2)
+            }
+        ]
+    };
+}
+function registerIssueTools(server) {
+    server.registerTool('list-issues', {
+        description: 'List issues—manually tracked bugs/errors opened against a service, with author/assignee names ' +
+            'resolved.',
+        inputSchema: {
+            title: zod_1.z.string().optional().describe('Substring match against the title'),
+            state: zod_1.z.enum(issueStates).optional().describe('Filter by issue state'),
+            service: zod_1.z.string().uuid().optional().describe('Restrict to a service'),
+            author: zod_1.z.string().uuid().optional().describe('Restrict to the user who opened the issue'),
+            assignee: zod_1.z.string().uuid().optional().describe('Restrict to the assigned user')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/issues/list', params)));
+    server.registerTool('get-issue', {
+        description: 'Retrieve a single issue by ID, with author/assignee/updated-by names resolved.',
+        inputSchema: {
+            id: zod_1.z.string().uuid().describe('The issue ID')
+        }
+    }, async ({ id }) => asText(await (0, api_1.fetchJSON)(`/issues/${id}`)));
+}

package/dist/tools/keyUsers.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerKeyUserTools = registerKeyUserTools;
+const zod_1 = require("zod");
+const api_1 = require("../api");
+function asText(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(data, null, 2)
+            }
+        ]
+    };
+}
+function registerKeyUserTools(server) {
+    server.registerTool('list-key-users', {
+        description: 'List key users—business stakeholders/contacts tracked for services (not system login users). ' +
+            'Each has a name, email and optional branch/cellphone.',
+        inputSchema: {
+            name: zod_1.z.string().optional().describe('Substring match against the name'),
+            email: zod_1.z.string().optional().describe('Substring match against the email'),
+            status: zod_1.z
+                .union([zod_1.z.boolean(), zod_1.z.literal('all')])
+                .optional()
+                .describe('Filter by active status (true, default) or "all" to include inactive ones')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/key-user/list', params)));
+    server.registerTool('list-service-key-users', {
+        description: 'List the links between services and their key users.',
+        inputSchema: {
+            service_id: zod_1.z.string().uuid().optional().describe('Restrict to a service'),
+            key_user_id: zod_1.z.string().uuid().optional().describe('Restrict to a key user'),
+            status: zod_1.z
+                .union([zod_1.z.boolean(), zod_1.z.literal('all')])
+                .optional()
+                .describe('Filter by the key user\'s active status (true, default) or "all"')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/service-key-user/list', params)));
+}

package/dist/tools/logs.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLogTools = registerLogTools;
+const zod_1 = require("zod");
+const api_1 = require("../api");
+const logLevels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'EXCEPTION'];
+function asText(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(data, null, 2)
+            }
+        ]
+    };
+}
+function registerLogTools(server) {
+    server.registerTool('list-logs', {
+        description: 'List logs with optional filters. Returns the raw log entries ordered by most recent first. ' +
+            'Use `get-error-histogram` instead when you only need error counts over time.',
+        inputSchema: {
+            service: zod_1.z.string().uuid().optional().describe('Service ID to filter by'),
+            hostname: zod_1.z.string().optional().describe('Exact hostname to filter by'),
+            username: zod_1.z.string().optional().describe('Exact username to filter by'),
+            ipv4: zod_1.z.string().optional().describe('Exact IPv4 address to filter by'),
+            service_path: zod_1.z.string().optional().describe('Substring match against the service path'),
+            is_exception: zod_1.z.boolean().optional().describe('Filter logs raised from an exception handler'),
+            log_level: zod_1.z.enum(logLevels).optional().describe('Exact log level to filter by'),
+            log_message: zod_1.z.string().optional().describe('Substring match against the log message'),
+            log_timestamp_from: zod_1.z
+                .string()
+                .optional()
+                .describe('ISO 8601 timestamp; only logs at or after this instant'),
+            log_timestamp_to: zod_1.z
+                .string()
+                .optional()
+                .describe('ISO 8601 timestamp; only logs at or before this instant')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/logs/list', params)));
+    server.registerTool('get-latest-logs', {
+        description: 'Get the most recent log per running instance (service + hostname + username), enriched ' +
+            'with service/company/sector info and liveness data (active run, last activity, whether more ' +
+            'than one live run was detected). This is the data behind the dashboard\'s service list.'
+    }, async () => asText(await (0, api_1.fetchJSON)('/logs/last')));
+    server.registerTool('get-log', {
+        description: 'Retrieve a single log entry by ID, including its full message and service context.',
+        inputSchema: {
+            id: zod_1.z.string().uuid().describe('The log ID')
+        }
+    }, async ({ id }) => asText(await (0, api_1.fetchJSON)(`/logs/${id}`)));
+    server.registerTool('get-error-histogram', {
+        description: 'Get a time-bucketed histogram of log counts and error/critical/exception counts for a service, ' +
+            'built from raw logs. Limited to however far back the raw logs retention goes. Use ' +
+            '`get-error-history` instead for a longer-range daily summary.',
+        inputSchema: {
+            service: zod_1.z.string().uuid().describe('Service ID (required)'),
+            hostname: zod_1.z.string().optional().describe('Restrict to a single hostname'),
+            username: zod_1.z.string().optional().describe('Restrict to a single username'),
+            bucket_minutes: zod_1.z
+                .number()
+                .int()
+                .min(1)
+                .max(1440)
+                .optional()
+                .describe('Bucket width in minutes (default: 60)')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/logs/error-histogram', params)));
+    server.registerTool('get-error-history', {
+        description: 'Get the daily consolidated error history for a service (total/error/critical/exception counts ' +
+            'per day), built by the nightly snapshot job. Covers a longer range than ' +
+            '`get-error-histogram`, which depends on raw log retention.',
+        inputSchema: {
+            service: zod_1.z.string().uuid().describe('Service ID (required)'),
+            from: zod_1.z.string().optional().describe('Start date (YYYY-MM-DD), inclusive'),
+            to: zod_1.z.string().optional().describe('End date (YYYY-MM-DD), inclusive')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/logs/error-history', params)));
+    server.registerTool('get-host-metrics', {
+        description: 'Get time-bucketed resource usage (CPU, memory, disk, process I/O) for a single running instance ' +
+            '(service + hostname + username), along with the machine\'s hardware limits. Samples are sent by ' +
+            'the jaylog client roughly every minute and retained for 48 hours.',
+        inputSchema: {
+            service: zod_1.z.string().uuid().describe('Service ID (required)'),
+            hostname: zod_1.z.string().min(1).describe('Hostname of the instance (required)'),
+            username: zod_1.z.string().min(1).describe('Username running the instance (required)'),
+            run_id: zod_1.z.string().uuid().optional().describe('Restrict to a single run; omit for the active run'),
+            bucket_minutes: zod_1.z
+                .number()
+                .int()
+                .min(1)
+                .max(1440)
+                .optional()
+                .describe('Bucket width in minutes (default: 1)')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/logs/host-metrics', params)));
+    server.registerTool('list-hosts', {
+        description: 'List registered host/instance records (one per run_id by default, or every heartbeat with ' +
+            '`all_runs`), including environment details (OS, Python version, git state, venv) reported once ' +
+            'per run by the jaylog client.',
+        inputSchema: {
+            service_id: zod_1.z.string().uuid().optional().describe('Restrict to a service'),
+            run_id: zod_1.z.string().uuid().optional().describe('Restrict to a single run'),
+            hostname: zod_1.z.string().optional().describe('Restrict to a hostname'),
+            username: zod_1.z.string().optional().describe('Restrict to a username'),
+            live: zod_1.z.boolean().optional().describe('Only include runs considered currently alive'),
+            all_runs: zod_1.z
+                .boolean()
+                .optional()
+                .describe('Return every run instead of only the most relevant one per instance')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/logs/hosts', params)));
+    server.registerTool('get-host-stats', {
+        description: 'Get an aggregate breakdown (value -> count) of execution mode, Python version, jaylog version, ' +
+            'venv kind and git branch across every active instance. Useful for a quick fleet overview.'
+    }, async () => asText(await (0, api_1.fetchJSON)('/logs/host-stats')));
+}

package/dist/tools/schedules.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScheduleTools = registerScheduleTools;
+const zod_1 = require("zod");
+const api_1 = require("../api");
+const repetitions = ['CONTINUO', 'DIARIO', 'SEMANA', 'DIA'];
+const weekDays = [
+    'SUNDAY',
+    'MONDAY',
+    'TUESDAY',
+    'WEDNESDAY',
+    'THURSDAY',
+    'FRIDAY',
+    'SATURDAY'
+];
+const sources = ['MANUAL', 'TASK_SCHEDULER'];
+function asText(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(data, null, 2)
+            }
+        ]
+    };
+}
+function registerScheduleTools(server) {
+    server.registerTool('list-service-schedules', {
+        description: 'List the scheduled run times for services—either manually registered or synced from the ' +
+            'host\'s Windows Task Scheduler (`source: TASK_SCHEDULER`, read-only). `repetition` drives which ' +
+            'other fields are set: CONTINUO (none), DIARIO (time only), SEMANA (day_of_week + time), DIA ' +
+            '(day_of_month + time).',
+        inputSchema: {
+            service_id: zod_1.z.string().uuid().optional().describe('Restrict to a service'),
+            repetition: zod_1.z.enum(repetitions).optional().describe('Filter by repetition kind'),
+            day_of_month: zod_1.z.number().int().min(1).max(31).optional().describe('Filter by day of month'),
+            day_of_week: zod_1.z.enum(weekDays).optional().describe('Filter by day of week'),
+            time: zod_1.z.string().optional().describe('Filter by exact time (HH:MM, 24h)'),
+            source: zod_1.z.enum(sources).optional().describe('Filter by origin of the schedule entry'),
+            status: zod_1.z.boolean().optional().describe('Include only active (true, default) or inactive schedules')
+        }
+    }, async (params) => asText(await (0, api_1.fetchJSON)('/service-schedule/list', params)));
+}

package/dist/tools/services.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServiceTools = registerServiceTools;
+const zod_1 = require("zod");
+const api_1 = require("../api");
+function asText(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(data, null, 2)
+            }
+        ]
+    };
+}
+function registerServiceTools(server) {
+    server.registerTool('list-services', {
+        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'),
+            company_id: zod_1.z.string().uuid().optional().describe('Restrict to a company'),
+            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,36 @@
 {
   "name": "jaylog-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "Model Context Protocol server for Jaylog observability (logs, metrics, services, schedules)",
+  "bin": {
+    "jaylog-mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "bun src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "login": "bun src/index.ts login",
+    "logout": "bun src/index.ts logout",
+    "build": "tsc && chmod +x dist/*.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "jaylog",
+    "mcp",
+    "observability",
+    "claude"
+  ],
+  "author": "gpocas",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  }
+}