@vairix/admin-mcp 1.0.0

package/README.md

@@ -0,0 +1,209 @@
+<div align="center">
+
+<img src="https://capsule-render.vercel.app/api?type=waving&color=0:1a1b27,100:6366f1&height=180&section=header&text=vairix-admin-mcp&fontSize=36&fontColor=ffffff&fontAlignY=35&desc=Log%20your%20hours%20with%20Claude%2C%20not%20clicks&descSize=16&descColor=a5b4fc&descAlignY=55" width="100%" />
+
+[![Node](https://img.shields.io/badge/node-%3E%3D18-43853d?style=flat-square&logo=node.js&logoColor=white)](https://nodejs.org)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+[![MCP](https://img.shields.io/badge/MCP-compatible-6366f1?style=flat-square&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9IndoaXRlIiBzdHJva2Utd2lkdGg9IjIiPjxwYXRoIGQ9Ik0xMiAyTDIgN2wxMCA1IDEwLTUtMTAtNXoiLz48cGF0aCBkPSJNMiAxN2wxMCA1IDEwLTUiLz48cGF0aCBkPSJNMiAxMmwxMCA1IDEwLTUiLz48L3N2Zz4=)](https://modelcontextprotocol.io)
+
+</div>
+
+<div align="center">
+
+### Talk to Claude. Your hours get logged.
+
+An [MCP server](https://modelcontextprotocol.io) that gives Claude direct access to [Vairix Admin](https://admin.vairix.com).<br>
+No more clicking through forms -- just describe what you need in plain language.
+
+</div>
+
+---
+
+<img src="assets/demo.gif" width="100%" alt="Demo" />
+
+---
+
+## Install
+
+One command. That's it.
+
+```bash
+claude mcp add vairix-admin -s user -- npx @vairix/admin-mcp
+```
+
+> `-s user` makes it available across **all** your projects, not just the current one.
+
+<details>
+<summary>Install from GitHub instead</summary>
+
+```bash
+claude mcp add vairix-admin -s user -- npx --yes github:Barralex/vairix-admin-mcp
+```
+
+</details>
+
+<details>
+<summary>Clone manually instead</summary>
+
+```bash
+git clone git@github.com:Barralex/vairix-admin-mcp.git
+cd vairix-admin-mcp
+npm install
+claude mcp add vairix-admin -s user -- node $(pwd)/build/index.js
+```
+
+</details>
+
+<details>
+<summary>Uninstall</summary>
+
+```bash
+claude mcp remove vairix-admin -s user
+```
+
+</details>
+
+## How it works
+
+```
+You: "Log 8 hours on Seekr for today: API refactor"
+                          |
+                    Claude Code (MCP)
+                          |
+               admin.vairix.com (HTTP)
+                          |
+                       Done.
+```
+
+**First time?** Claude will open your browser (Chrome, Edge, or Brave) so you can login normally. Your session cookies are stored in the OS keychain -- passwords are **never** saved. After that, everything runs via direct HTTP requests. Sub-second. No browser needed.
+
+Session expired? Just say _"authenticate"_ again.
+
+## What you can say
+
+```
+"Authenticate with Vairix Admin"              -- login (once per session)
+
+"What days am I missing this month?"           -- find gaps
+"Log 8h on Seekr for Monday through Friday"    -- bulk log
+"Log 4 hours on Cordage for today: Bug fixes"  -- single entry
+
+"How many hours did I log on Seekr?"           -- totals
+"Show me a breakdown by category"              -- summary
+"Show my hours for this month"                 -- list entries
+
+"Delete the hour entry from today"             -- remove entry
+```
+
+No special syntax. No commands to memorize. Just describe what you want.
+
+## Tools under the hood
+
+Claude picks the right tool automatically. You don't need to call them directly.
+
+| Tool | What it does |
+|:-----|:-------------|
+| **`auth`** | Opens your browser for login. Session saved to OS keychain. |
+| **`auth_status`** | Checks if your session is still valid. |
+| **`logout`** | Clears saved session. |
+| **`set_main_project`** | Sets your default project so you don't have to specify it every time. |
+| **`get_pending_days`** | Finds workdays where you haven't logged hours yet. |
+| **`get_hours`** | Lists your entries. Filter by project, date range, or scope. |
+| **`get_hours_summary`** | Totals and breakdowns by project, category, or date. |
+| **`get_projects`** | Shows which projects you can log to. |
+| **`create_hours`** | Logs hours for one or more dates at once. |
+| **`delete_hours`** | Removes an entry by ID. |
+
+## Security
+
+Your credentials are handled carefully:
+
+- **Passwords** are never stored. You login through your real browser.
+- **Session cookies** live in your OS keychain (macOS Keychain / Linux libsecret / Windows Credential Vault).
+- **No bundled browser**. Uses your existing Chrome, Edge, or Brave.
+
+## WSL Setup
+
+Running inside WSL requires extra steps since there's no default browser or keychain.
+
+**1. Install a browser inside WSL:**
+
+```bash
+# Option A: Chromium
+sudo apt install -y chromium-browser
+
+# Option B: Google Chrome
+wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
+sudo dpkg -i google-chrome-stable_current_amd64.deb
+sudo apt -f install -y
+```
+
+**2. Install keychain dependencies:**
+
+```bash
+sudo apt install -y libsecret-1-dev gnome-keyring
+```
+
+Start the keyring daemon (add to your `.bashrc`):
+
+```bash
+eval $(gnome-keyring-daemon --start --components=secrets 2>/dev/null)
+export GNOME_KEYRING_CONTROL
+```
+
+**3. Verify setup:**
+
+```bash
+npx --yes github:Barralex/vairix-admin-mcp --health-check
+```
+
+> **Note:** Browser auth requires a display server. WSL2 with WSLg provides this automatically. If using WSL1 or WSLg isn't working, you'll need an X11 server (e.g., VcXsrv) with `export DISPLAY=:0`.
+
+## Troubleshooting
+
+| Problem | Solution |
+|:--------|:---------|
+| "No Chromium-based browser found" | Install Chrome, Edge, or Brave. |
+| "No Chromium-based browser found inside WSL" | Install a browser _inside_ WSL, not on Windows. See [WSL Setup](#wsl-setup). |
+| "Not authenticated" | Say _"authenticate with Vairix"_. |
+| "Session expired" | Same -- just authenticate again. |
+| Hours creation fails | Check the error. Admin validates dates (no future dates, etc). |
+| Keychain errors on WSL/Linux | Install libsecret and gnome-keyring. See [WSL Setup](#wsl-setup). |
+| Server won't start | Run `--health-check` to diagnose: `npx --yes github:Barralex/vairix-admin-mcp --health-check` |
+
+## Releasing
+
+Every push to `main` automatically publishes to npm. The version is bumped based on the commit message prefix:
+
+| Commit prefix | Bump | Example |
+|:--------------|:-----|:--------|
+| `feat!:` or `BREAKING CHANGE` | **major** | `1.0.0` → `2.0.0` |
+| `feat:` | **minor** | `1.0.0` → `1.1.0` |
+| `fix:`, `refactor:`, `chore:`, etc. | **patch** | `1.0.0` → `1.0.1` |
+
+The CI pipeline bumps `package.json`, publishes the package, and commits the new version back to `main`. No manual version management needed.
+
+## Development
+
+```bash
+npm run dev          # watch mode
+npm run build        # compile
+npm test             # run tests
+npm start            # run server
+```
+
+## Requirements
+
+- Node.js >= 18
+- Chrome, Edge, or Brave
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI
+
+<div align="center">
+
+---
+
+**[Vairix](https://vairix.com)** | MIT License
+
+<img src="https://capsule-render.vercel.app/api?type=waving&color=0:1a1b27,100:6366f1&height=80&section=footer" width="100%" />
+
+</div>

package/build/api.d.ts

@@ -0,0 +1,48 @@
+export interface ProjectOption {
+    id: string;
+    name: string;
+}
+export interface HourEntry {
+    id: number;
+    initial_date: string;
+    hours: number;
+    category: number;
+    description: string;
+    project_id: number;
+    staff_id: number;
+    extra_allocation: boolean;
+    in_home: boolean;
+    confirm: boolean;
+    billable: boolean | null;
+}
+export declare function categoryName(cat: number): string;
+export declare function categoryId(name: string): string;
+export interface GetHoursFilter {
+    scope?: string;
+    date_from?: string;
+    date_to?: string;
+    project_id?: string;
+}
+export declare function getHours(filter?: GetHoursFilter): Promise<HourEntry[]>;
+export declare function getPendingDays(): Promise<string[]>;
+export declare function getProjects(): Promise<ProjectOption[]>;
+export declare function createHour(params: {
+    date: string;
+    project_id: string;
+    hours: string;
+    category: string;
+    description: string;
+    extra_allocation?: boolean;
+    in_home?: boolean;
+}): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function deleteHour(id: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function batchDeleteHours(ids: string[]): Promise<{
+    success: boolean;
+    message: string;
+}>;

package/build/api.js

@@ -0,0 +1,263 @@
+import { loadSession, isSessionValid } from "./auth.js";
+const BASE_URL = "https://admin.vairix.com";
+// Session cache with TTL — avoids re-validating on every tool call
+let cachedSession = null;
+let sessionValidatedAt = 0;
+const SESSION_TTL = 60_000;
+async function session() {
+    if (cachedSession && Date.now() - sessionValidatedAt < SESSION_TTL) {
+        return cachedSession;
+    }
+    if (cachedSession) {
+        const valid = await isSessionValid(cachedSession);
+        if (valid) {
+            sessionValidatedAt = Date.now();
+            return cachedSession;
+        }
+    }
+    const saved = await loadSession();
+    if (!saved)
+        throw new Error("Not authenticated. Use the `auth` tool first.");
+    const valid = await isSessionValid(saved);
+    if (!valid)
+        throw new Error("Session expired. Use the `auth` tool to login again.");
+    if (!cachedSession || cachedSession.cookies !== saved.cookies) {
+        formDataCache = null;
+    }
+    cachedSession = saved;
+    sessionValidatedAt = Date.now();
+    return saved;
+}
+let formDataCache = null;
+const FORM_DATA_TTL = 300_000;
+async function fetchFormData() {
+    if (formDataCache && Date.now() - formDataCache.fetchedAt < FORM_DATA_TTL) {
+        return formDataCache;
+    }
+    const s = await session();
+    const res = await fetch(`${BASE_URL}/admin/daily_hours/new`, {
+        headers: { Cookie: s.cookies },
+        redirect: "follow",
+    });
+    if (res.status !== 200)
+        throw new Error(`Failed to load form: ${res.status}`);
+    const html = await res.text();
+    const formTokenMatch = html.match(/name="authenticity_token"[^>]*value="([^"]+)"/);
+    const csrfFormToken = formTokenMatch ? formTokenMatch[1] : s.csrfToken;
+    const metaTokenMatch = html.match(/meta name="csrf-token" content="([^"]+)"/);
+    const csrfMetaToken = metaTokenMatch ? metaTokenMatch[1] : s.csrfToken;
+    let staffId = "";
+    const staffMatch = html.match(/name="daily_hour\[staff_id\]"[\s\S]*?option[^>]*value="(\d+)"[^>]*selected/);
+    if (staffMatch) {
+        staffId = staffMatch[1];
+    }
+    else {
+        const altMatch = html.match(/name="daily_hour\[staff_id\]"[\s\S]*?selected[^>]*value="(\d+)"/);
+        if (altMatch)
+            staffId = altMatch[1];
+        else
+            throw new Error("Could not find staff_id");
+    }
+    const projects = [];
+    const projectSelectMatch = html.match(/name="daily_hour\[project_id\]"[^>]*>([\s\S]*?)<\/select>/);
+    if (projectSelectMatch) {
+        const regex = /<option value="(\d+)">([^<]+)<\/option>/g;
+        let m;
+        while ((m = regex.exec(projectSelectMatch[1])) !== null) {
+            projects.push({ id: m[1], name: m[2] });
+        }
+    }
+    formDataCache = { csrfFormToken, csrfMetaToken, staffId, projects, fetchedAt: Date.now() };
+    return formDataCache;
+}
+async function apiGet(path) {
+    const s = await session();
+    return fetch(`${BASE_URL}${path}`, {
+        headers: { Cookie: s.cookies },
+        redirect: "follow",
+    });
+}
+async function apiPost(path, body) {
+    const s = await session();
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const form = await fetchFormData();
+        const params = new URLSearchParams({
+            authenticity_token: form.csrfFormToken,
+            ...body,
+        });
+        const res = await fetch(`${BASE_URL}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                Cookie: s.cookies,
+            },
+            body: params.toString(),
+            redirect: "manual",
+        });
+        if (res.status === 302 || res.status === 303 || res.status === 200) {
+            return res;
+        }
+        if (attempt === 0) {
+            formDataCache = null;
+            continue;
+        }
+        return res;
+    }
+    throw new Error("POST failed after retry");
+}
+async function apiDelete(path) {
+    const s = await session();
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const form = await fetchFormData();
+        const res = await fetch(`${BASE_URL}${path}`, {
+            method: "DELETE",
+            headers: {
+                Cookie: s.cookies,
+                "X-CSRF-Token": form.csrfMetaToken,
+            },
+            redirect: "manual",
+        });
+        if (res.status === 200 || res.status === 302 || res.status === 303) {
+            return res;
+        }
+        if (attempt === 0) {
+            formDataCache = null;
+            continue;
+        }
+        return res;
+    }
+    throw new Error("DELETE failed after retry");
+}
+const CATEGORY_MAP = {
+    1: "Desarrollador",
+    2: "Gerente de proyecto",
+    3: "Testing",
+    4: "Arquitecto",
+    5: "Otro",
+};
+const CATEGORY_REVERSE = {
+    desarrollador: "1",
+    dev: "1",
+    developer: "1",
+    "gerente de proyecto": "2",
+    pm: "2",
+    testing: "3",
+    qa: "3",
+    arquitecto: "4",
+    architect: "4",
+    otro: "5",
+    other: "5",
+};
+export function categoryName(cat) {
+    return CATEGORY_MAP[cat] ?? `Unknown(${cat})`;
+}
+export function categoryId(name) {
+    return CATEGORY_REVERSE[name.toLowerCase()] ?? "1";
+}
+const MAX_PAGES = 10;
+const PER_PAGE = 100;
+export async function getHours(filter = {}) {
+    const { scope = "current_month", date_from, date_to, project_id } = filter;
+    const all = [];
+    for (let page = 1; page <= MAX_PAGES; page++) {
+        const params = new URLSearchParams({ scope, page: String(page), per_page: String(PER_PAGE) });
+        if (date_from)
+            params.set("q[initial_date_gteq]", date_from);
+        if (date_to)
+            params.set("q[initial_date_lteq]", date_to);
+        if (project_id)
+            params.set("q[project_id_eq]", project_id);
+        const res = await apiGet(`/admin/daily_hours.json?${params}`);
+        if (res.status !== 200)
+            throw new Error(`Failed to get hours: ${res.status}`);
+        const entries = await res.json();
+        all.push(...entries);
+        if (entries.length < PER_PAGE)
+            break;
+    }
+    return all;
+}
+export async function getPendingDays() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth();
+    const today = now.getDate();
+    const monthPrefix = `${year}-${String(month + 1).padStart(2, "0")}`;
+    const monthStart = `${monthPrefix}-01`;
+    const todayStr = `${monthPrefix}-${String(today).padStart(2, "0")}`;
+    let hours = await getHours({ scope: "current_month" });
+    // At month boundaries, server (UTC) may be in a different month than the client.
+    // Use date range filters instead of fetching all hours.
+    if (!hours.some((h) => h.initial_date.startsWith(monthPrefix))) {
+        hours = await getHours({ scope: "all", date_from: monthStart, date_to: todayStr });
+    }
+    const loggedDates = new Set(hours.map((h) => h.initial_date));
+    const pending = [];
+    for (let day = 1; day <= today; day++) {
+        const d = new Date(year, month, day);
+        const dow = d.getDay();
+        if (dow === 0 || dow === 6)
+            continue;
+        const dateStr = `${year}-${String(month + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+        if (!loggedDates.has(dateStr))
+            pending.push(dateStr);
+    }
+    return pending;
+}
+export async function getProjects() {
+    return (await fetchFormData()).projects;
+}
+export async function createHour(params) {
+    const { staffId } = await fetchFormData();
+    const body = {
+        "daily_hour[initial_date]": params.date,
+        "daily_hour[project_id]": params.project_id,
+        "daily_hour[staff_id]": staffId,
+        "daily_hour[hours]": params.hours,
+        "daily_hour[category]": categoryId(params.category),
+        "daily_hour[description]": params.description,
+        "daily_hour[in_home]": params.in_home ? "1" : "0",
+        "daily_hour[extra_allocation]": params.extra_allocation ? "1" : "0",
+        commit: "Guardar Horas Proyectos",
+    };
+    const res = await apiPost("/admin/daily_hours", body);
+    if (res.status === 302 || res.status === 303) {
+        return { success: true, message: `Hours created for ${params.date}` };
+    }
+    const responseBody = await res.text();
+    const errorMatch = responseBody.match(/<li>([^<]+)<\/li>/g);
+    const errors = errorMatch
+        ? errorMatch.map((e) => e.replace(/<\/?li>/g, "")).join(", ")
+        : `status ${res.status}`;
+    return {
+        success: false,
+        message: `Failed to create hours for ${params.date}: ${errors}`,
+    };
+}
+export async function deleteHour(id) {
+    await apiDelete(`/admin/daily_hours/${id}`);
+    return { success: true, message: `Hour entry ${id} deleted` };
+}
+export async function batchDeleteHours(ids) {
+    const s = await session();
+    const form = await fetchFormData();
+    const params = new URLSearchParams();
+    params.set("authenticity_token", form.csrfFormToken);
+    params.set("batch_action", "destroy");
+    for (const id of ids) {
+        params.append("collection_selection[]", id);
+    }
+    const res = await fetch(`${BASE_URL}/admin/daily_hours/batch_action`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Cookie: s.cookies,
+        },
+        body: params.toString(),
+        redirect: "manual",
+    });
+    if (res.status === 302 || res.status === 303) {
+        return { success: true, message: `${ids.length} entries deleted` };
+    }
+    return { success: false, message: `Batch delete failed (status ${res.status})` };
+}

package/build/auth.d.ts

@@ -0,0 +1,15 @@
+export interface SessionData {
+    cookies: string;
+    csrfToken: string;
+    email: string;
+    savedAt: string;
+}
+export declare function loadSession(): Promise<SessionData | null>;
+export declare function clearSession(): Promise<void>;
+export declare function saveMainProject(projectId: string, projectName: string): Promise<void>;
+export declare function loadMainProject(): Promise<{
+    id: string;
+    name: string;
+} | null>;
+export declare function isSessionValid(session: SessionData): Promise<boolean>;
+export declare function authenticate(): Promise<SessionData>;

package/build/auth.js

@@ -0,0 +1,154 @@
+import { chromium } from "playwright-core";
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+import keytar from "keytar";
+import { getBrowserPaths, detectEnvironment, log } from "./diagnostics.js";
+const SERVICE = "vairix-admin-mcp";
+const BASE_URL = "https://admin.vairix.com";
+const LOGIN_URL = `${BASE_URL}/admin/login`;
+async function saveSession(session) {
+    await keytar.setPassword(SERVICE, "session", JSON.stringify(session));
+}
+export async function loadSession() {
+    try {
+        const data = await keytar.getPassword(SERVICE, "session");
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    catch (e) {
+        log("error", `Failed to load session: ${e instanceof Error ? e.message : e}`);
+        return null;
+    }
+}
+export async function clearSession() {
+    await keytar.deletePassword(SERVICE, "session");
+    await keytar.deletePassword(SERVICE, "main_project").catch(() => { });
+}
+export async function saveMainProject(projectId, projectName) {
+    await keytar.setPassword(SERVICE, "main_project", JSON.stringify({ id: projectId, name: projectName }));
+}
+export async function loadMainProject() {
+    try {
+        const data = await keytar.getPassword(SERVICE, "main_project");
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function isSessionValid(session) {
+    try {
+        const res = await fetch(`${BASE_URL}/admin/daily_hours.json?scope=today`, {
+            headers: { Cookie: session.cookies },
+            redirect: "manual",
+        });
+        return res.status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+function getScreenSize() {
+    try {
+        if (process.platform === "win32") {
+            const output = execSync('powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $s = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea; Write-Output \\"$($s.Width),$($s.Height)\\""', { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+            const [w, h] = output.split(",").map(Number);
+            if (w && h)
+                return { width: w, height: h };
+        }
+        else if (process.platform === "darwin") {
+            const output = execSync("system_profiler SPDisplaysDataType 2>/dev/null | grep Resolution", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+            const match = output.match(/(\d+)\s*x\s*(\d+)/);
+            if (match)
+                return { width: Number(match[1]), height: Number(match[2]) };
+        }
+    }
+    catch { }
+    return { width: 1920, height: 1080 };
+}
+function findChromiumBrowser() {
+    const paths = getBrowserPaths();
+    for (const p of paths) {
+        if (existsSync(p))
+            return p;
+    }
+    const env = detectEnvironment();
+    if (env.isWSL) {
+        throw new Error("No Chromium-based browser found inside WSL. You need a browser installed in WSL itself, not just on Windows. Run with --health-check for setup instructions.");
+    }
+    throw new Error("No Chromium-based browser found. Install Chrome, Edge, or Brave and try again.");
+}
+export async function authenticate() {
+    log("info", "Authentication started");
+    const chromePath = findChromiumBrowser();
+    log("info", `Browser found: ${chromePath}`);
+    const windowWidth = 900;
+    const windowHeight = 700;
+    const screen = getScreenSize();
+    const left = Math.round((screen.width - windowWidth) / 2);
+    const top = Math.round((screen.height - windowHeight) / 2);
+    const browser = await chromium.launch({
+        headless: false,
+        executablePath: chromePath,
+        args: [
+            "--disable-blink-features=AutomationControlled",
+            `--window-size=${windowWidth},${windowHeight}`,
+            `--window-position=${left},${top}`,
+        ],
+    });
+    const context = await browser.newContext({
+        viewport: { width: windowWidth, height: windowHeight - 80 },
+    });
+    const page = await context.newPage();
+    await page.goto(LOGIN_URL);
+    await page.waitForLoadState("domcontentloaded");
+    if (process.platform === "win32") {
+        try {
+            execSync(`powershell -Command "(New-Object -ComObject WScript.Shell).AppActivate('admin.vairix.com')"`, { stdio: "ignore" });
+        }
+        catch { }
+    }
+    else {
+        await page.bringToFront();
+    }
+    try {
+        await page.waitForURL((url) => !url.toString().includes("/login"), {
+            timeout: 120_000,
+        });
+    }
+    catch {
+        await browser.close();
+        log("warn", "Authentication timed out");
+        throw new Error("Login timed out. Chrome was closed or login was not completed in time. Try again with `auth`.");
+    }
+    await page.waitForLoadState("networkidle");
+    // Capture cookies
+    const browserCookies = await context.cookies();
+    const cookieHeader = browserCookies
+        .map((c) => `${c.name}=${c.value}`)
+        .join("; ");
+    // Get CSRF token
+    const csrfToken = await page.evaluate(() => {
+        const meta = document.querySelector('meta[name="csrf-token"]');
+        return meta?.getAttribute("content") ?? "";
+    });
+    // Get user email from the page
+    const email = await page.evaluate(() => {
+        const links = Array.from(document.querySelectorAll("a"));
+        const emailLink = links.find((a) => a.textContent?.includes("@vairix.com"));
+        return emailLink?.textContent?.trim() ?? "unknown";
+    });
+    await browser.close();
+    const session = {
+        cookies: cookieHeader,
+        csrfToken,
+        email,
+        savedAt: new Date().toISOString(),
+    };
+    await saveSession(session);
+    log("info", `Authentication successful: ${email}`);
+    return session;
+}

package/build/diagnostics.d.ts

@@ -0,0 +1,26 @@
+export declare function isWSL(): boolean;
+export interface Environment {
+    isWSL: boolean;
+    platform: string;
+    nodeVersion: string;
+    nodeMajor: number;
+}
+export declare function detectEnvironment(): Environment;
+export declare function getBrowserPaths(): string[];
+export interface CheckResult {
+    name: string;
+    status: "ok" | "warn" | "fail";
+    message: string;
+    fix?: string;
+}
+export declare function checkNodeVersion(): CheckResult;
+export declare function checkBrowser(): CheckResult;
+export declare function checkKeychain(): Promise<CheckResult>;
+export declare function runAllChecks(): Promise<CheckResult[]>;
+export declare function runStartupChecks(): {
+    fatal?: string;
+    warnings: string[];
+};
+export declare function formatCheckResults(checks: CheckResult[]): string;
+export declare function enhanceError(error: unknown): string;
+export declare function log(level: "info" | "warn" | "error", message: string): void;

package/build/diagnostics.js

@@ -0,0 +1,197 @@
+import { existsSync, readFileSync, renameSync, mkdirSync, appendFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+// ---- Environment detection ----
+export function isWSL() {
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    try {
+        const version = readFileSync("/proc/version", "utf-8");
+        return /microsoft/i.test(version);
+    }
+    catch {
+        return false;
+    }
+}
+export function detectEnvironment() {
+    const ver = process.version.replace(/^v/, "");
+    return {
+        isWSL: isWSL(),
+        platform: process.platform,
+        nodeVersion: ver,
+        nodeMajor: parseInt(ver.split(".")[0], 10),
+    };
+}
+// ---- Browser paths (shared with auth.ts) ----
+export function getBrowserPaths() {
+    return [
+        // macOS - Chrome
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        // macOS - Edge
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        // macOS - Brave
+        "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+        // macOS - Chromium
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        // Linux - Chrome
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        // Linux - Edge
+        "/usr/bin/microsoft-edge",
+        "/usr/bin/microsoft-edge-stable",
+        // Linux - Brave
+        "/usr/bin/brave-browser",
+        "/usr/bin/brave-browser-stable",
+        // Linux - Chromium
+        "/usr/bin/chromium-browser",
+        "/usr/bin/chromium",
+        // Windows - Chrome
+        "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+        // Windows - Edge
+        "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+        // Windows - Brave
+        "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+        "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+    ];
+}
+export function checkNodeVersion() {
+    const env = detectEnvironment();
+    if (env.nodeMajor >= 18) {
+        return { name: "Node.js", status: "ok", message: `v${env.nodeVersion}` };
+    }
+    return {
+        name: "Node.js",
+        status: "fail",
+        message: `v${env.nodeVersion} (requires >= 18)`,
+        fix: "Install Node.js 18 or later: https://nodejs.org",
+    };
+}
+export function checkBrowser() {
+    const env = detectEnvironment();
+    const paths = getBrowserPaths();
+    const found = paths.find((p) => existsSync(p));
+    if (found) {
+        const name = found.split("/").pop() ?? found;
+        return { name: "Browser", status: "ok", message: name };
+    }
+    if (env.isWSL) {
+        return {
+            name: "Browser",
+            status: "fail",
+            message: "No Chromium browser found inside WSL",
+            fix: "Install Chrome in WSL: sudo apt install -y chromium-browser\nOr: wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb && sudo dpkg -i google-chrome-stable_current_amd64.deb && sudo apt -f install -y",
+        };
+    }
+    return {
+        name: "Browser",
+        status: "fail",
+        message: "No Chromium-based browser found",
+        fix: "Install Chrome, Edge, or Brave.",
+    };
+}
+export async function checkKeychain() {
+    const env = detectEnvironment();
+    try {
+        const keytar = await import("keytar");
+        const testKey = "vairix-admin-mcp-healthcheck";
+        await keytar.default.setPassword(testKey, "test", "ok");
+        const val = await keytar.default.getPassword(testKey, "test");
+        await keytar.default.deletePassword(testKey, "test");
+        if (val === "ok") {
+            return { name: "Keychain", status: "ok", message: "Working" };
+        }
+        return { name: "Keychain", status: "fail", message: "Read/write test failed" };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (env.isWSL) {
+            return {
+                name: "Keychain",
+                status: "fail",
+                message: `Keychain unavailable in WSL: ${msg}`,
+                fix: "Install libsecret and gnome-keyring:\n  sudo apt install -y libsecret-1-dev gnome-keyring\n  eval $(gnome-keyring-daemon --start --components=secrets 2>/dev/null)",
+            };
+        }
+        return {
+            name: "Keychain",
+            status: "fail",
+            message: `Keychain error: ${msg}`,
+            fix: env.platform === "linux"
+                ? "Install libsecret: sudo apt install -y libsecret-1-dev"
+                : undefined,
+        };
+    }
+}
+export async function runAllChecks() {
+    return [
+        checkNodeVersion(),
+        checkBrowser(),
+        await checkKeychain(),
+    ];
+}
+export function runStartupChecks() {
+    const warnings = [];
+    const env = detectEnvironment();
+    if (env.nodeMajor < 18) {
+        return {
+            fatal: `Node.js ${env.nodeVersion} is not supported. Please upgrade to Node.js 18 or later.`,
+            warnings,
+        };
+    }
+    if (env.isWSL) {
+        warnings.push("Running inside WSL. Browser auth and keychain require extra setup. Run with --health-check for details.");
+    }
+    return { warnings };
+}
+export function formatCheckResults(checks) {
+    const lines = checks.map((c) => {
+        const icon = c.status === "ok" ? "[OK]" : c.status === "warn" ? "[WARN]" : "[FAIL]";
+        let line = `${icon} ${c.name}: ${c.message}`;
+        if (c.fix) {
+            line += `\n     Fix: ${c.fix}`;
+        }
+        return line;
+    });
+    const hasFailure = checks.some((c) => c.status === "fail");
+    const summary = hasFailure
+        ? "\nSome checks failed. Fix the issues above before using the server."
+        : "\nAll checks passed.";
+    return lines.join("\n") + summary;
+}
+// ---- Error enhancement ----
+export function enhanceError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const env = detectEnvironment();
+    if (!env.isWSL)
+        return msg;
+    if (/no chromium|browser.*not found|executable.*not found|launch/i.test(msg)) {
+        return `${msg}\n\nWSL detected: You need a browser installed inside WSL, not just on Windows.\nInstall Chrome: sudo apt install -y chromium-browser\nOr run --health-check for full setup instructions.`;
+    }
+    if (/keytar|keychain|secret|dbus/i.test(msg)) {
+        return `${msg}\n\nWSL detected: The OS keychain requires libsecret and gnome-keyring.\nInstall: sudo apt install -y libsecret-1-dev gnome-keyring\nThen: eval $(gnome-keyring-daemon --start --components=secrets 2>/dev/null)`;
+    }
+    return msg;
+}
+// ---- Logging ----
+const LOG_DIR = join(homedir(), ".vairix-admin-mcp", "logs");
+const LOG_FILE = join(LOG_DIR, "vairix-admin-mcp.log");
+const MAX_LOG_SIZE = 1_048_576; // 1MB
+export function log(level, message) {
+    try {
+        mkdirSync(LOG_DIR, { recursive: true });
+        try {
+            const stat = statSync(LOG_FILE);
+            if (stat.size > MAX_LOG_SIZE) {
+                renameSync(LOG_FILE, `${LOG_FILE}.1`);
+            }
+        }
+        catch { }
+        const timestamp = new Date().toISOString();
+        const line = `${timestamp} [${level.toUpperCase()}] ${message}\n`;
+        appendFileSync(LOG_FILE, line);
+    }
+    catch { }
+}

package/build/index.d.ts

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

package/build/index.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { authenticate, loadSession, isSessionValid, clearSession, saveMainProject, loadMainProject } from "./auth.js";
+import { getHours, getPendingDays, getProjects, createHour, deleteHour, categoryName, } from "./api.js";
+import { detectEnvironment, runAllChecks, runStartupChecks, formatCheckResults, enhanceError, log, } from "./diagnostics.js";
+const server = new McpServer({
+    name: "vairix-admin",
+    version: "1.0.0",
+});
+function formatHours(hours) {
+    if (hours.length === 0)
+        return "No hours found.";
+    return hours
+        .map((h) => `[${h.id}] ${h.initial_date} | ${h.hours}h | project:${h.project_id} | ${categoryName(h.category)} | ${h.description}${h.extra_allocation ? " (Extra)" : ""}`)
+        .join("\n");
+}
+// ---- Tools ----
+server.tool("auth", "Opens Chrome so the user can login to Vairix Admin manually. Required before using any other tool. Captures session cookies and stores them in the OS keychain. The user will see a Chrome window — do not call this without telling them first.", {}, { idempotentHint: true, openWorldHint: true }, async () => {
+    try {
+        const session = await authenticate();
+        const projects = await getProjects();
+        const mainProject = await loadMainProject();
+        const projectList = projects.map((p) => `- [${p.id}] ${p.name}`).join("\n");
+        const mainInfo = mainProject
+            ? `Current main project: [${mainProject.id}] ${mainProject.name}`
+            : "No main project set. Use `set_main_project` to set one.";
+        return {
+            content: [{
+                    type: "text",
+                    text: `Authenticated as ${session.email}. Session saved.\n\nAvailable projects:\n${projectList}\n\n${mainInfo}\n\nIMPORTANT: If no main project is set, you MUST ask the user to pick their main project from the list above using a selection UI (e.g. AskUserQuestion with the project names as options). Then call \`set_main_project\` with the chosen project_id and project_name.`,
+                }],
+        };
+    }
+    catch (e) {
+        log("error", `Auth failed: ${e instanceof Error ? e.message : e}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Auth failed: ${enhanceError(e)}`,
+                }],
+            isError: true,
+        };
+    }
+});
+server.tool("auth_status", "Check if the user has a valid session. Call this before other tools if unsure whether the user is authenticated. Returns the user's email and session age if valid.", {}, { readOnlyHint: true, openWorldHint: true }, async () => {
+    const session = await loadSession();
+    if (!session) {
+        return {
+            content: [{
+                    type: "text",
+                    text: "Not authenticated. Use `auth` tool to open Chrome and login.",
+                }],
+        };
+    }
+    const valid = await isSessionValid(session);
+    if (!valid) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Session expired (was ${session.email}, saved ${session.savedAt}). Use \`auth\` to login again.`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Authenticated as ${session.email}. Session from ${session.savedAt}.`,
+            }],
+    };
+});
+server.tool("logout", "Clear the saved session from the OS keychain. The user will need to call `auth` again to re-authenticate.", {}, { destructiveHint: true, idempotentHint: true }, async () => {
+    try {
+        await clearSession();
+    }
+    catch { }
+    return {
+        content: [{ type: "text", text: "Session cleared. Use `auth` to login again." }],
+    };
+});
+server.tool("set_main_project", "Set the user's main project for logging hours. Call `get_projects` first to see available projects. The main project is saved in the OS keychain and used as default for `create_hours`. IMPORTANT: When the user mentions a project by name (e.g. 'cargame horas en Seekr', 'log hours to ProjectX'), call `get_projects` to find the matching project_id, then call this tool to switch before creating hours.", {
+    project_id: z.string().describe("The project ID from `get_projects`"),
+    project_name: z.string().describe("The project name (for display)"),
+}, { idempotentHint: true }, async ({ project_id, project_name }) => {
+    try {
+        await saveMainProject(project_id, project_name);
+        return {
+            content: [{ type: "text", text: `Main project set to [${project_id}] ${project_name}.` }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("get_pending_days", "Get workdays that are missing hour entries for the current month. Use this to find out which days the user still needs to log hours for.", {}, { readOnlyHint: true, openWorldHint: true }, async () => {
+    try {
+        const days = await getPendingDays();
+        if (days.length === 0) {
+            return { content: [{ type: "text", text: "All hours are up to date! No pending days." }] };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Pending days (missing hours):\n${days.map((d) => `- ${d}`).join("\n")}`,
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("get_hours", "Get the user's logged hour entries. Returns ID, date, hours, project_id, category, and description for each entry. Use the ID from results to delete entries with `delete_hours`. For totals and aggregation, use `get_hours_summary` instead.", {
+    scope: z
+        .enum(["current_month", "all", "today", "yesterday"])
+        .default("current_month")
+        .describe("Time scope: current_month (default), today, yesterday, or all"),
+    project_id: z
+        .string()
+        .optional()
+        .describe("Filter by project ID (from `get_projects`)"),
+    date_from: z
+        .string()
+        .optional()
+        .describe("Filter start date (YYYY-MM-DD). Auto-sets scope to 'all'."),
+    date_to: z
+        .string()
+        .optional()
+        .describe("Filter end date (YYYY-MM-DD). Auto-sets scope to 'all'."),
+}, { readOnlyHint: true, openWorldHint: true }, async ({ scope, project_id, date_from, date_to }) => {
+    try {
+        const filter = { scope };
+        if (project_id)
+            filter.project_id = project_id;
+        if (date_from) {
+            filter.date_from = date_from;
+            filter.scope = "all";
+        }
+        if (date_to) {
+            filter.date_to = date_to;
+            filter.scope = "all";
+        }
+        let hours = await getHours(filter);
+        if (filter.scope === "current_month") {
+            const now = new Date();
+            const monthPrefix = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+            if (!hours.some((h) => h.initial_date.startsWith(monthPrefix))) {
+                filter.scope = "all";
+                filter.date_from = `${monthPrefix}-01`;
+                filter.date_to = `${monthPrefix}-${String(now.getDate()).padStart(2, "0")}`;
+                hours = await getHours(filter);
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Hours (${filter.scope}, ${hours.length} entries):\n${formatHours(hours)}`,
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("get_projects", "List projects the user can log hours to. Returns project ID and name. You MUST call this before `create_hours` to get a valid project_id.", {}, { readOnlyHint: true, openWorldHint: true }, async () => {
+    try {
+        const projects = await getProjects();
+        if (projects.length === 0) {
+            return { content: [{ type: "text", text: "No projects found." }] };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Available projects:\n${projects.map((p) => `- [${p.id}] ${p.name}`).join("\n")}`,
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("get_hours_summary", "Get aggregated hour totals with breakdown. Use this for questions like 'how many hours on project X?' or 'hours by category this month'. Defaults to current month.", {
+    project_id: z
+        .string()
+        .optional()
+        .describe("Filter by project ID (from `get_projects`)"),
+    date_from: z
+        .string()
+        .optional()
+        .describe("Start date (YYYY-MM-DD). Defaults to first day of current month."),
+    date_to: z
+        .string()
+        .optional()
+        .describe("End date (YYYY-MM-DD). Defaults to today."),
+    group_by: z
+        .enum(["project", "category", "date"])
+        .default("project")
+        .describe("How to group the breakdown: project, category, or date"),
+}, { readOnlyHint: true, openWorldHint: true }, async ({ project_id, date_from, date_to, group_by }) => {
+    try {
+        const now = new Date();
+        const monthPrefix = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+        const effectiveFrom = date_from ?? `${monthPrefix}-01`;
+        const effectiveTo = date_to ?? `${monthPrefix}-${String(now.getDate()).padStart(2, "0")}`;
+        const filter = {
+            scope: "all",
+            date_from: effectiveFrom,
+            date_to: effectiveTo,
+        };
+        if (project_id)
+            filter.project_id = project_id;
+        const hours = await getHours(filter);
+        const totalHours = hours.reduce((sum, h) => sum + h.hours, 0);
+        const projectMap = new Map();
+        if (group_by === "project") {
+            const projects = await getProjects();
+            for (const p of projects)
+                projectMap.set(p.id, p.name);
+        }
+        const groups = new Map();
+        for (const h of hours) {
+            let key;
+            if (group_by === "project") {
+                key = projectMap.get(String(h.project_id)) ?? `Project ${h.project_id}`;
+            }
+            else if (group_by === "category") {
+                key = categoryName(h.category);
+            }
+            else {
+                key = h.initial_date;
+            }
+            groups.set(key, (groups.get(key) ?? 0) + h.hours);
+        }
+        const sorted = [...groups.entries()].sort((a, b) => b[1] - a[1]);
+        const breakdown = sorted
+            .map(([key, hrs]) => {
+            const pct = totalHours > 0 ? ((hrs / totalHours) * 100).toFixed(1) : "0.0";
+            return `- ${key}: ${hrs}h (${pct}%)`;
+        })
+            .join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Summary (${effectiveFrom} to ${effectiveTo}, ${hours.length} entries):\nTotal: ${totalHours}h\n\nBreakdown by ${group_by}:\n${breakdown}`,
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("create_hours", "Log hours for one or more dates. Uses the main project if project_id is omitted — if the user mentions a different project by name, call `set_main_project` first to switch. Cannot log future dates. To update an existing entry, delete it first with `delete_hours` then recreate.", {
+    dates: z.union([
+        z.array(z.string()),
+        z.string().transform((s) => {
+            try {
+                return JSON.parse(s);
+            }
+            catch {
+                return [s];
+            }
+        }),
+    ]).pipe(z.array(z.string()).min(1)).describe('One or more dates in YYYY-MM-DD format. Example: ["2026-02-24", "2026-02-25"]'),
+    project_id: z
+        .string()
+        .regex(/^\d+$/, "project_id must be numeric")
+        .optional()
+        .describe("Project ID — get valid IDs from `get_projects`. If omitted, uses the main project set via `set_main_project`."),
+    hours: z
+        .string()
+        .default("8")
+        .refine((v) => { const n = Number(v); return !isNaN(n) && n > 0 && n <= 24; }, "Hours must be a number between 1 and 24")
+        .describe("Hours to log per day (default: 8)"),
+    category: z
+        .string()
+        .default("desarrollador")
+        .describe("One of: desarrollador, pm, testing, arquitecto, otro (default: desarrollador)"),
+    description: z
+        .string()
+        .describe("Work description for the time entry"),
+    extra_allocation: z
+        .boolean()
+        .default(false)
+        .describe("Set true only for secondary/extra project allocations"),
+    in_home: z
+        .boolean()
+        .default(false)
+        .describe("Set true if working from home"),
+}, { openWorldHint: true }, async ({ dates, project_id, hours, category, description, extra_allocation, in_home }) => {
+    try {
+        let pid = project_id;
+        if (!pid) {
+            const mainProject = await loadMainProject();
+            if (!mainProject) {
+                return { content: [{ type: "text", text: "No project_id provided and no main project set. Use `set_main_project` first or pass a project_id." }], isError: true };
+            }
+            pid = mainProject.id;
+        }
+        const today = new Date().toISOString().slice(0, 10);
+        const futureDates = dates.filter((d) => d > today);
+        if (futureDates.length > 0) {
+            return { content: [{ type: "text", text: `Cannot log future dates: ${futureDates.join(", ")}` }], isError: true };
+        }
+        const BATCH_SIZE = 3;
+        const results = [];
+        for (let i = 0; i < dates.length; i += BATCH_SIZE) {
+            const batch = dates.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.all(batch.map((date) => createHour({ date, project_id: pid, hours, category, description, extra_allocation, in_home })));
+            for (let j = 0; j < batch.length; j++) {
+                const res = batchResults[j];
+                results.push(`${batch[j]}: ${res.success ? "OK" : res.message}`);
+            }
+        }
+        return { content: [{ type: "text", text: `Results:\n${results.join("\n")}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+server.tool("delete_hours", "Delete one or more hour entries by ID. Get IDs from `get_hours` results. This action is irreversible — you MUST confirm with the user before calling this tool, listing the entries that will be deleted. Pass a single ID as ['123'] or multiple as ['123','456']. Multiple IDs use a single batch request.", {
+    ids: z.union([
+        z.array(z.string()),
+        z.string().transform((s) => {
+            try {
+                return JSON.parse(s);
+            }
+            catch {
+                return [s];
+            }
+        }),
+        z.number().transform((n) => [String(n)]),
+    ]).pipe(z.array(z.string()).min(1)).describe("Entry IDs to delete. Example: ['182353'] or ['182353','182351','182350']"),
+}, { destructiveHint: true, openWorldHint: true }, async ({ ids }) => {
+    try {
+        const results = await Promise.all(ids.map((id) => deleteHour(id).then(() => id).catch((e) => `${id}: ${e instanceof Error ? e.message : e}`)));
+        const deleted = results.filter((r) => !r.includes(":"));
+        const failed = results.filter((r) => r.includes(":"));
+        const parts = [];
+        if (deleted.length)
+            parts.push(`${deleted.length} entries deleted`);
+        if (failed.length)
+            parts.push(`Failed: ${failed.join(", ")}`);
+        return { content: [{ type: "text", text: parts.join(". ") }], ...(failed.length ? { isError: true } : {}) };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : e}` }], isError: true };
+    }
+});
+async function main() {
+    const env = detectEnvironment();
+    log("info", `Startup: Node ${env.nodeVersion}, ${env.platform}${env.isWSL ? " (WSL)" : ""}`);
+    if (process.argv.includes("--health-check")) {
+        const checks = await runAllChecks();
+        console.log(formatCheckResults(checks));
+        process.exit(checks.some((c) => c.status === "fail") ? 1 : 0);
+    }
+    const startup = runStartupChecks();
+    if (startup.fatal) {
+        log("error", `Fatal: ${startup.fatal}`);
+        console.error(startup.fatal);
+        process.exit(1);
+    }
+    for (const w of startup.warnings) {
+        log("warn", w);
+        console.error(`[WARN] ${w}`);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("vairix-admin MCP running");
+}
+main().catch((e) => {
+    log("error", `Fatal: ${e instanceof Error ? e.message : e}`);
+    console.error(e);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vairix/admin-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Vairix Admin - automate time tracking with Claude",
+  "type": "module",
+  "bin": {
+    "vairix-admin-mcp": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "test": "node --import tsx --test tests/*.test.ts"
+  },
+  "files": [
+    "build"
+  ],
+  "keywords": [
+    "mcp",
+    "vairix",
+    "time-tracking",
+    "claude",
+    "active-admin"
+  ],
+  "author": "Vairix",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "keytar": "^7.9.0",
+    "playwright-core": "^1.58.2",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/keytar": "^4.4.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}