@deerdesign/deertools 1.2.5 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deerdesign/deertools",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/cli.js

@@ -35,6 +35,7 @@ async function main(argv) {
     mcp: c.cmdMcp, doctor: c.cmdDoctor, audit: c.cmdAudit, profile: c.cmdProfile,
     completion: c.cmdCompletion, catalog: c.cmdCatalog, deliveries: c.cmdDeliveries,
     supplier: c.cmdSupplier, rendermind: c.cmdRendermind, baselinker: c.cmdBaseLinker,
+    update: require('./updater').cmdUpdate,
   };
 
   if (pos.length === 0 && !flags.help && !flags.version && process.stdout.isTTY) {
@@ -48,15 +49,28 @@ async function main(argv) {
 
   const cmd = pos.shift() || 'help';
 
-  if (cmd === 'help' || cmd === '--help' || flags.help) { process.stdout.write(c.HELP); return 0; }
-  if (cmd === '--version' || cmd === 'version' || flags.version) { process.stdout.write(`${require('../package.json').version}\n`); return 0; }
-  if (!table[cmd]) { process.stderr.write(`Nieznana komenda „${cmd}”.\n${c.HELP}`); return 2; }
+  const shouldCheck = !flags.json && cmd !== 'update' && process.env.NODE_ENV !== 'test';
+  const updatePromise = shouldCheck ? require('./updater').checkUpdate().catch(() => null) : null;
+
+  const finish = async (code = 0) => {
+    if (updatePromise) {
+      try {
+        const info = await updatePromise;
+        if (info && info.hasUpdate) require('./updater').printUpdateNotice(info);
+      } catch (_) {}
+    }
+    return code;
+  };
+
+  if (cmd === 'help' || cmd === '--help' || flags.help) { process.stdout.write(c.HELP); return finish(0); }
+  if (cmd === '--version' || cmd === 'version' || flags.version) { process.stdout.write(`${require('../package.json').version}\n`); return finish(0); }
+  if (!table[cmd]) { process.stderr.write(`Nieznana komenda „${cmd}”.\n${c.HELP}`); return finish(2); }
   try {
     await table[cmd](pos, flags);
-    return 0;
+    return finish(0);
   } catch (e) {
     if (!e.silent) process.stderr.write(`Błąd: ${e.message}\n`);
-    return e.exitCode || 1;
+    return finish(e.exitCode || 1);
   }
 }
 

package/src/commands.js

@@ -543,6 +543,7 @@ Integracje MCP i Agenci AI (DeerSkills Hub):
   deertools api <produkt> <METODA> </ścieżka>           Wywołuje bezpośrednio API produktu.
 
 Narzędzia systemowe:
+  deertools update                                      Sprawdza i podpowiada aktualizację CLI.
   deertools doctor [--json]                             Pełna diagnostyka połączeń, portów i kluczy.
   deertools audit [--limit 25] [--clear] [--json]       Historia operacji i wywołań API.
   deertools completion [install|zsh|bash]               Autouzupełnianie w powłoce po wciśnięciu Tab.

package/src/login.js

@@ -33,9 +33,9 @@ function normalizeScope(input) {
   return VALID_SCOPES.filter((s) => set.has(s)).join(' ');
 }
 
-function buildAuthorizeUrl(authorizationEndpoint, { redirectUri, state, scope, clientName, challenge }) {
+function buildAuthorizeUrl(authorizationEndpoint, { redirectUri, state, scope, clientName, challenge, clientId = CLIENT_ID }) {
   const u = new URL(authorizationEndpoint);
-  u.searchParams.set('client_id', CLIENT_ID);
+  u.searchParams.set('client_id', clientId);
   u.searchParams.set('redirect_uri', redirectUri);
   u.searchParams.set('response_type', 'code');
   u.searchParams.set('code_challenge', challenge);
@@ -67,13 +67,13 @@ function evaluateCallback(query, { expectedState }) {
 }
 
 /** Wymiana kodu na klucz: bezpośrednie zapytanie CLI -> serwer (klucz nigdy nie przechodzi przez przeglądarkę). */
-async function exchangeCode(product, tokenEndpoint, { code, verifier, redirectUri, fetchImpl = fetch }) {
+async function exchangeCode(product, tokenEndpoint, { code, verifier, redirectUri, clientId = CLIENT_ID, fetchImpl = fetch }) {
   let res;
   try {
     res = await fetchImpl(tokenEndpoint, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
-      body: JSON.stringify({ grant_type: 'authorization_code', code, code_verifier: verifier, redirect_uri: redirectUri, client_id: CLIENT_ID }),
+      body: JSON.stringify({ grant_type: 'authorization_code', code, code_verifier: verifier, redirect_uri: redirectUri, client_id: clientId }),
     });
   } catch (e) {
     throw new Error(`Nie udało się połączyć z serwerem produktu ${product.name}: ${e.message}`);
@@ -162,6 +162,28 @@ function openBrowser(url) {
   exec(cmd, () => { /* gdy się nie uda, użytkownik ma adres wypisany w terminalu */ });
 }
 
+async function registerDynamicClient(registrationEndpoint, { redirectUri, clientName, fetchImpl = fetch }) {
+  if (!registrationEndpoint) return null;
+  try {
+    const res = await fetchImpl(registrationEndpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify({
+        client_name: clientName || 'DeerTools CLI',
+        redirect_uris: [redirectUri],
+        token_endpoint_auth_method: 'none',
+        grant_types: ['authorization_code', 'refresh_token'],
+        response_types: ['code'],
+      }),
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    return json.client_id || null;
+  } catch (_) {
+    return null;
+  }
+}
+
 /**
  * Logowanie OAuth 2.1 dla aplikacji natywnej (RFC 8252): kod autoryzacyjny + PKCE, powrót na 127.0.0.1 (losowy port).
  * opts.metadata pozwala podać adresy bez pobierania (testy). Zwraca wpis poświadczeń zapisany na dysku.
@@ -179,6 +201,7 @@ async function login(product, opts = {}) {
   return new Promise((resolve, reject) => {
     let finished = false;
     let redirectUri = null;
+    let activeClientId = CLIENT_ID;
 
     const server = http.createServer(async (req, res) => {
       const url = new URL(req.url, 'http://127.0.0.1');
@@ -192,7 +215,7 @@ async function login(product, opts = {}) {
         return;
       }
       try {
-        const entry = await exchangeCode(product, meta.token_endpoint, { code: result.code, verifier: pkce.verifier, redirectUri, fetchImpl: opts.fetchImpl });
+        const entry = await exchangeCode(product, meta.token_endpoint, { code: result.code, verifier: pkce.verifier, redirectUri, clientId: activeClientId, fetchImpl: opts.fetchImpl });
         credentials.saveProduct(product.id, entry);
         res.writeHead(200, headers);
         res.end(page('Zalogowano', `Klucz do produktu ${product.name} został zapisany w terminalu. Możesz zamknąć to okno.`, true));
@@ -215,9 +238,17 @@ async function login(product, opts = {}) {
     }
 
     server.on('error', (e) => done(e));
-    server.listen(opts.port || 0, '127.0.0.1', () => {
+    server.listen(opts.port || 0, '127.0.0.1', async () => {
       redirectUri = `http://127.0.0.1:${server.address().port}/callback`;
-      const url = buildAuthorizeUrl(meta.authorization_endpoint, { redirectUri, state, scope, clientName, challenge: pkce.challenge });
+      let authScope = scope;
+      if (meta.registration_endpoint) {
+        const dynId = await registerDynamicClient(meta.registration_endpoint, { redirectUri, clientName, fetchImpl: opts.fetchImpl });
+        if (dynId) {
+          activeClientId = dynId;
+          authScope = 'openid email profile offline_access';
+        }
+      }
+      const url = buildAuthorizeUrl(meta.authorization_endpoint, { redirectUri, state, scope: authScope, clientName, challenge: pkce.challenge, clientId: activeClientId });
       log(`Zakres: ${scope}. Otwieram przeglądarkę — zaloguj się w produkcie ${product.name} i kliknij „Zezwól na dostęp”.`);
       log(`Jeśli przeglądarka się nie otworzy, wejdź na:\n${url}\n`);
       if (open) open(url);
@@ -225,4 +256,4 @@ async function login(product, opts = {}) {
   });
 }
 
-module.exports = { CLIENT_ID, createPkce, normalizeScope, buildAuthorizeUrl, evaluateCallback, exchangeCode, discoverOAuth, login };
+module.exports = { CLIENT_ID, createPkce, normalizeScope, buildAuthorizeUrl, evaluateCallback, exchangeCode, discoverOAuth, login, registerDynamicClient };

package/src/updater.js

@@ -0,0 +1,128 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CACHE_TTL_MS = 12 * 60 * 60 * 1000; // 12 hours
+const REGISTRY_URL = 'https://registry.npmjs.org/@deerdesign/deertools/latest';
+const PKG = require('../package.json');
+
+function getCachePath() {
+  const dir = path.join(os.homedir(), '.deertools');
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  } catch (_) {}
+  return path.join(dir, 'update-check.json');
+}
+
+function compareSemver(a, b) {
+  const pa = String(a).replace(/^v/, '').split('.').map(Number);
+  const pb = String(b).replace(/^v/, '').split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+
+async function fetchLatestVersion() {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), 2500);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      headers: { 'Accept': 'application/json', 'User-Agent': 'deertools-cli' },
+      signal: ctrl.signal,
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    return json.version || null;
+  } catch (_) {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+async function checkUpdate() {
+  const cacheFile = getCachePath();
+  const now = Date.now();
+  let cached = null;
+
+  try {
+    if (fs.existsSync(cacheFile)) {
+      cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+    }
+  } catch (_) {}
+
+  let latestVersion = cached && cached.latestVersion ? cached.latestVersion : null;
+
+  if (!cached || !cached.lastChecked || (now - cached.lastChecked > CACHE_TTL_MS)) {
+    const fetched = await fetchLatestVersion();
+    if (fetched) {
+      latestVersion = fetched;
+      try {
+        fs.writeFileSync(cacheFile, JSON.stringify({ lastChecked: now, latestVersion }), 'utf8');
+      } catch (_) {}
+    }
+  }
+
+  if (latestVersion && compareSemver(latestVersion, PKG.version) > 0) {
+    return {
+      hasUpdate: true,
+      current: PKG.version,
+      latest: latestVersion,
+    };
+  }
+
+  return { hasUpdate: false, current: PKG.version, latest: latestVersion };
+}
+
+function printUpdateNotice(updateInfo) {
+  if (!updateInfo || !updateInfo.hasUpdate) return;
+  const { current, latest } = updateInfo;
+  const line1 = `Dostępna nowa wersja DeerTools CLI: ${current} → ${latest}`;
+  const line2 = `Zaktualizuj: npm install -g @deerdesign/deertools@latest`;
+  const line3 = `lub użyj:    npx -y @deerdesign/deertools@latest <komenda>`;
+  const len = Math.max(line1.length, line2.length, line3.length) + 4;
+  const border = '─'.repeat(len);
+
+  process.stderr.write(`\n\x1b[33m┌${border}┐\x1b[0m\n`);
+  process.stderr.write(`\x1b[33m│  ${line1.padEnd(len - 2)}│\x1b[0m\n`);
+  process.stderr.write(`\x1b[33m│  ${line2.padEnd(len - 2)}│\x1b[0m\n`);
+  process.stderr.write(`\x1b[33m│  ${line3.padEnd(len - 2)}│\x1b[0m\n`);
+  process.stderr.write(`\x1b[33m└${border}┘\x1b[0m\n\n`);
+}
+
+async function cmdUpdate(pos, flags) {
+  process.stdout.write(`Sprawdzam aktualizacje w rejestrze npm...\n`);
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    process.stdout.write(`Nie udało się połączyć z rejestrem npm. Sprawdź połączenie z internetem.\n`);
+    return 1;
+  }
+
+  const cmp = compareSemver(latest, PKG.version);
+  if (cmp <= 0) {
+    process.stdout.write(`✓ DeerTools CLI jest w najnowszej wersji (${PKG.version}).\n`);
+    return 0;
+  }
+
+  process.stdout.write(`\nZnaleziono nowszą wersję: ${PKG.version} → \x1b[32m${latest}\x1b[0m\n\n`);
+  process.stdout.write(`Aby zaktualizować instalację globalną, uruchom:\n`);
+  process.stdout.write(`  \x1b[36mnpm install -g @deerdesign/deertools@latest\x1b[0m\n\n`);
+  process.stdout.write(`Jeśli instalacja wymaga uprawnień administratora:\n`);
+  process.stdout.write(`  \x1b[36msudo npm install -g @deerdesign/deertools@latest\x1b[0m\n\n`);
+  process.stdout.write(`A jeśli korzystasz z npx, każda komenda zawsze pobiera najnowszą wersję z tagiem @latest:\n`);
+  process.stdout.write(`  \x1b[36mnpx -y @deerdesign/deertools@latest <komenda>\x1b[0m\n\n`);
+  return 0;
+}
+
+module.exports = {
+  checkUpdate,
+  printUpdateNotice,
+  cmdUpdate,
+  compareSemver,
+  fetchLatestVersion,
+};