@k-system/tickr-mcp 1.22.0 → 1.23.0

package/dist/auth.d.ts

@@ -10,9 +10,16 @@ export declare function login(config: TickrConfig, username: string, password: s
 export declare function refreshToken(config: TickrConfig): Promise<TokenPair>;
 /**
  * Vrátí Authorization header value.
- * Pokud config má apiKey (tk_...), použije ho přímo.
- * Jinak použije JWT token (auto-refresh pokud expiruje).
+ * Priorita:
+ * 1. API key (tkr_...) — přímé použití, žádná expiry
+ * 2. Device Grant session (~/.tickr/sessions/) — auto-refresh
+ * 3. JWT token (login/password) — auto-refresh
  */
 export declare function getAuthHeader(config: TickrConfig): Promise<string>;
+/**
+ * Inicializace device grant session při startu serveru.
+ * Načte existující session z disku — pokud existuje a je platná, nastaví cache.
+ */
+export declare function initDeviceGrantSession(config: TickrConfig): void;
 export {};
 //# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -1,4 +1,7 @@
+import { getDeviceGrantToken, loadSession, refreshAccessToken, saveSession, } from "./device-grant.js";
 let currentTokens = null;
+// Aktuální device grant session (pokud je aktivní)
+let activeSession = null;
 /** Přihlášení přes username/password — vrátí JWT token pair */
 export async function login(config, username, password) {
     const res = await fetch(`${config.apiUrl}/api/auth/login`, {
@@ -40,21 +43,74 @@ export async function refreshToken(config) {
 }
 /**
  * Vrátí Authorization header value.
- * Pokud config má apiKey (tk_...), použije ho přímo.
- * Jinak použije JWT token (auto-refresh pokud expiruje).
+ * Priorita:
+ * 1. API key (tkr_...) — přímé použití, žádná expiry
+ * 2. Device Grant session (~/.tickr/sessions/) — auto-refresh
+ * 3. JWT token (login/password) — auto-refresh
  */
 export async function getAuthHeader(config) {
-    // API key auth — jednoduché, bez expiry
+    // 1. API key auth — jednoduché, bez expiry
     if (config.apiKey) {
         return `Bearer ${config.apiKey}`;
     }
-    // JWT auth — refresh pokud token brzy vyprší (30s buffer)
+    // 2. Device Grant session — auto-refresh
+    if (config.tenantId && config.agentName) {
+        return `Bearer ${await getDeviceGrantAuthToken(config)}`;
+    }
+    // 3. JWT auth — refresh pokud token brzy vyprší (30s buffer)
     if (currentTokens && currentTokens.expiresAt - Date.now() < 30_000) {
         await refreshToken(config);
     }
     if (!currentTokens) {
-        throw new Error("Not authenticated — set TICKR_API_KEY or call login()");
+        throw new Error("Not authenticated — set TICKR_API_KEY or configure device grant");
     }
     return `Bearer ${currentTokens.accessToken}`;
 }
+/**
+ * Device Grant auth token s auto-refresh a auto-pairing.
+ * Pokud session neexistuje, spustí interaktivní pairing flow.
+ */
+async function getDeviceGrantAuthToken(config) {
+    // Zkus cache
+    if (activeSession && activeSession.expiresAt - Date.now() > 30_000) {
+        return activeSession.accessToken;
+    }
+    // Zkus refresh existující session
+    if (activeSession && activeSession.refreshToken) {
+        try {
+            const result = await refreshAccessToken(config, activeSession.refreshToken);
+            activeSession = {
+                accessToken: result.access_token,
+                refreshToken: result.refresh_token,
+                expiresAt: Date.now() + result.expires_in * 1000,
+                agentIdentity: result.agent_identity,
+                apiUrl: config.apiUrl,
+                tenantId: config.tenantId,
+            };
+            saveSession(config.agentName, activeSession);
+            return activeSession.accessToken;
+        }
+        catch {
+            activeSession = null;
+        }
+    }
+    // Načti z disku nebo spusť pairing
+    const token = await getDeviceGrantToken(config, config.agentName, config.tenantId);
+    // Aktualizuj cache
+    activeSession = loadSession(config.agentName);
+    return token;
+}
+/**
+ * Inicializace device grant session při startu serveru.
+ * Načte existující session z disku — pokud existuje a je platná, nastaví cache.
+ */
+export function initDeviceGrantSession(config) {
+    if (!config.agentName || !config.tenantId)
+        return;
+    const session = loadSession(config.agentName);
+    if (session) {
+        activeSession = session;
+        console.error(`[tickr] ✓ Connected as ${session.agentIdentity}`);
+    }
+}
 //# sourceMappingURL=auth.js.map

package/dist/config.d.ts

@@ -2,6 +2,10 @@ export interface TickrConfig {
     apiUrl: string;
     apiKey?: string;
     defaultProject?: string;
+    /** Tenant ID pro device grant auth (UUID) */
+    tenantId?: string;
+    /** Jméno agenta pro device grant session storage */
+    agentName?: string;
 }
 /** Načte konfiguraci z env vars nebo ~/.tickr/config.json */
 export declare function loadConfig(): TickrConfig;

package/dist/config.js

@@ -6,9 +6,11 @@ export function loadConfig() {
     const apiUrl = process.env.TICKR_API_URL;
     const apiKey = process.env.TICKR_API_KEY;
     const defaultProject = process.env.TICKR_DEFAULT_PROJECT;
+    const tenantId = process.env.TICKR_TENANT_ID;
+    const agentName = process.env.TICKR_AGENT_NAME;
     // Env vars mají prioritu
     if (apiUrl && apiKey) {
-        const config = { apiUrl, apiKey, defaultProject };
+        const config = { apiUrl, apiKey, defaultProject, tenantId, agentName };
         validateConfig(config);
         return config;
     }
@@ -21,6 +23,8 @@ export function loadConfig() {
             apiUrl: apiUrl || file.apiUrl || "https://localhost:6001",
             apiKey: apiKey || file.apiKey || "",
             defaultProject: defaultProject || file.defaultProject,
+            tenantId: tenantId || file.tenantId,
+            agentName: agentName || file.agentName,
         };
         validateConfig(config);
         return config;
@@ -31,6 +35,8 @@ export function loadConfig() {
             apiUrl: apiUrl || "https://localhost:6001",
             apiKey: apiKey || "",
             defaultProject,
+            tenantId,
+            agentName,
         };
         validateConfig(config);
         return config;
@@ -38,8 +44,8 @@ export function loadConfig() {
 }
 /** Validace konfigurace — loguje varování pro problematické hodnoty */
 function validateConfig(config) {
-    if (!config.apiKey) {
-        console.error("[tickr-mcp] WARNING: No API key configured — tools will fail with 401");
+    if (!config.apiKey && !config.tenantId) {
+        console.error("[tickr-mcp] WARNING: No API key or tenant ID configured — set TICKR_API_KEY or TICKR_TENANT_ID + TICKR_AGENT_NAME for device grant");
     }
     if (config.apiUrl && !config.apiUrl.startsWith("http://") && !config.apiUrl.startsWith("https://")) {
         console.error(`[tickr-mcp] WARNING: apiUrl "${config.apiUrl}" doesn't start with http(s)://`);

package/dist/device-grant.d.ts

@@ -0,0 +1,53 @@
+import type { TickrConfig } from "./config.js";
+interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    interval: number;
+    expires_in: number;
+}
+interface TokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    agent_identity: string;
+}
+export interface StoredSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    agentIdentity: string;
+    apiUrl: string;
+    tenantId: string;
+}
+/** Načte uloženou session — vrátí null pokud neexistuje nebo je poškozená */
+export declare function loadSession(agentName: string): StoredSession | null;
+/** Uloží session na disk */
+export declare function saveSession(agentName: string, session: StoredSession): void;
+/** Smaže uloženou session */
+export declare function clearSession(agentName: string): void;
+/**
+ * Zahájí device authorization flow — vrátí device code a user code.
+ * Agent zobrazí user code v terminálu, člověk ho zadá v browseru.
+ */
+export declare function initiateDeviceGrant(config: TickrConfig, tenantId: string): Promise<DeviceCodeResponse>;
+/**
+ * Polluje /oauth/token dokud člověk neschválí párování.
+ * Vrátí access + refresh token, nebo vyhodí chybu při expiraci/zamítnutí.
+ */
+export declare function pollForDeviceGrant(config: TickrConfig, deviceCode: string, interval: number, expiresIn: number, onStatus?: (message: string) => void): Promise<TokenResponse>;
+/**
+ * Obnoví access token přes refresh token grant.
+ * Vrátí nový token pár (rotace — starý refresh token je zneplatněn).
+ */
+export declare function refreshAccessToken(config: TickrConfig, refreshToken: string): Promise<TokenResponse>;
+/**
+ * Hlavní entry point: získej platný access token.
+ * 1. Pokud existuje uložená session a token je platný → vrať
+ * 2. Pokud token expiruje → auto-refresh
+ * 3. Pokud refresh selže → spusť device grant flow
+ */
+export declare function getDeviceGrantToken(config: TickrConfig, agentName: string, tenantId: string, onPairingRequired?: (userCode: string, verificationUri: string) => void): Promise<string>;
+export {};
+//# sourceMappingURL=device-grant.d.ts.map

package/dist/device-grant.js

@@ -0,0 +1,194 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// --- Session storage ---
+const SESSIONS_DIR = join(homedir(), ".tickr", "sessions");
+function ensureSessionsDir() {
+    if (!existsSync(SESSIONS_DIR)) {
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+}
+function sessionPath(agentName) {
+    const safe = agentName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(SESSIONS_DIR, `${safe}.json`);
+}
+/** Načte uloženou session — vrátí null pokud neexistuje nebo je poškozená */
+export function loadSession(agentName) {
+    try {
+        const path = sessionPath(agentName);
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Uloží session na disk */
+export function saveSession(agentName, session) {
+    ensureSessionsDir();
+    const path = sessionPath(agentName);
+    writeFileSync(path, JSON.stringify(session, null, 2), { mode: 0o600 });
+}
+/** Smaže uloženou session */
+export function clearSession(agentName) {
+    try {
+        const path = sessionPath(agentName);
+        if (existsSync(path)) {
+            const { unlinkSync } = require("node:fs");
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Ignoruj
+    }
+}
+// --- Device Authorization Grant flow ---
+/**
+ * Zahájí device authorization flow — vrátí device code a user code.
+ * Agent zobrazí user code v terminálu, člověk ho zadá v browseru.
+ */
+export async function initiateDeviceGrant(config, tenantId) {
+    const res = await fetch(`${config.apiUrl}/oauth/device/authorize`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ clientId: "claude-agent", tenantId }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Device authorization failed: ${res.status} — ${body}`);
+    }
+    return (await res.json()).data;
+}
+/**
+ * Polluje /oauth/token dokud člověk neschválí párování.
+ * Vrátí access + refresh token, nebo vyhodí chybu při expiraci/zamítnutí.
+ */
+export async function pollForDeviceGrant(config, deviceCode, interval, expiresIn, onStatus) {
+    const deadline = Date.now() + expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval * 1000);
+        try {
+            const res = await fetch(`${config.apiUrl}/oauth/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    grantType: "urn:ietf:params:oauth:grant-type:device_code",
+                    deviceCode,
+                }),
+            });
+            if (res.ok) {
+                return (await res.json());
+            }
+            const error = (await res.json());
+            if (error.error === "authorization_pending") {
+                onStatus?.("Waiting for approval...");
+                continue;
+            }
+            if (error.error === "slow_down") {
+                interval = Math.min(interval + 1, 15);
+                onStatus?.("Slowing down polling...");
+                continue;
+            }
+            if (error.error === "expired_token") {
+                throw new Error("Device code expired — please try pairing again");
+            }
+            if (error.error === "access_denied") {
+                throw new Error("Pairing denied by user");
+            }
+            throw new Error(`Token exchange error: ${error.error} — ${error.error_description}`);
+        }
+        catch (err) {
+            if (err instanceof Error && (err.message.includes("expired") || err.message.includes("denied"))) {
+                throw err;
+            }
+            // Síťová chyba — pokračuj v pollingu
+            onStatus?.("Connection error, retrying...");
+        }
+    }
+    throw new Error("Device code expired — please try pairing again");
+}
+/**
+ * Obnoví access token přes refresh token grant.
+ * Vrátí nový token pár (rotace — starý refresh token je zneplatněn).
+ */
+export async function refreshAccessToken(config, refreshToken) {
+    const res = await fetch(`${config.apiUrl}/oauth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            grantType: "refresh_token",
+            refreshToken,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Token refresh failed: ${res.status} — ${body}`);
+    }
+    return (await res.json());
+}
+// --- Integrační funkce ---
+/**
+ * Hlavní entry point: získej platný access token.
+ * 1. Pokud existuje uložená session a token je platný → vrať
+ * 2. Pokud token expiruje → auto-refresh
+ * 3. Pokud refresh selže → spusť device grant flow
+ */
+export async function getDeviceGrantToken(config, agentName, tenantId, onPairingRequired) {
+    // Zkus načíst existující session
+    let session = loadSession(agentName);
+    if (session) {
+        // Token ještě platný (30s buffer)
+        if (session.expiresAt - Date.now() > 30_000) {
+            return session.accessToken;
+        }
+        // Zkus refresh
+        try {
+            const result = await refreshAccessToken(config, session.refreshToken);
+            session = {
+                accessToken: result.access_token,
+                refreshToken: result.refresh_token,
+                expiresAt: Date.now() + result.expires_in * 1000,
+                agentIdentity: result.agent_identity,
+                apiUrl: config.apiUrl,
+                tenantId,
+            };
+            saveSession(agentName, session);
+            return session.accessToken;
+        }
+        catch {
+            // Refresh selhal — session expirovala, potřebujeme nové párování
+            clearSession(agentName);
+        }
+    }
+    // Žádná platná session — spusť device grant flow
+    const deviceResponse = await initiateDeviceGrant(config, tenantId);
+    // Oznám uživateli
+    if (onPairingRequired) {
+        onPairingRequired(deviceResponse.user_code, deviceResponse.verification_uri);
+    }
+    else {
+        console.error(`[tickr] Agent is not paired.`);
+        console.error(`[tickr] Open ${deviceResponse.verification_uri}`);
+        console.error(`[tickr] Enter code: ${deviceResponse.user_code}`);
+        console.error(`[tickr] Waiting for approval... (expires in ${Math.round(deviceResponse.expires_in / 60)} min)`);
+    }
+    const tokenResponse = await pollForDeviceGrant(config, deviceResponse.device_code, deviceResponse.interval, deviceResponse.expires_in, (msg) => console.error(`[tickr] ${msg}`));
+    // Ulož session
+    const newSession = {
+        accessToken: tokenResponse.access_token,
+        refreshToken: tokenResponse.refresh_token,
+        expiresAt: Date.now() + tokenResponse.expires_in * 1000,
+        agentIdentity: tokenResponse.agent_identity,
+        apiUrl: config.apiUrl,
+        tenantId,
+    };
+    saveSession(agentName, newSession);
+    console.error(`[tickr] ✓ Paired as ${tokenResponse.agent_identity}`);
+    return newSession.accessToken;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=device-grant.js.map

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { loadConfig } from "./config.js";
+import { initDeviceGrantSession } from "./auth.js";
 import { ApiClient } from "./api-client.js";
 import { debugLog, isDebugEnabled } from "./debug-logger.js";
 // Tools
@@ -98,6 +99,8 @@ import { registerPendingTasksResource } from "./resources/pending-tasks-resource
 import { initSignalRClient, stopSignalRClient } from "./signalr-client.js";
 export async function startServer() {
     const config = loadConfig();
+    // Inicializace device grant session (pokud je konfigurována)
+    initDeviceGrantSession(config);
     const api = new ApiClient(config);
     // Startup health check — ověření dostupnosti API
     const healthy = await api.healthCheck();
@@ -109,7 +112,7 @@ export async function startServer() {
     }
     const server = new McpServer({
         name: "tickr",
-        version: "1.22.0",
+        version: "1.23.0",
     });
     // Debug logging wrapper (dedup odstraněn — nefunkční cross-process, řeší se na API straně: TKR-ADR-0043)
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-system/tickr-mcp",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "MCP server for Tickr project management — 56 tools + setup CLI wizard",
   "type": "module",
   "main": "./dist/index.js",