agentgui 1.0.917 → 1.0.918

package/lib/speech-manager.js

@@ -1,200 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { createRequire } from 'module';
-let speechModule = null;
-let _broadcastSync = null;
-let _syncClients = null;
-let _queries = null;
-
-export function initSpeechManager({ broadcastSync, syncClients, queries }) {
-  _broadcastSync = broadcastSync;
-  _syncClients = syncClients;
-  _queries = queries;
-}
-export async function ensurePocketTtsSetup(onProgress) {
-  const r = createRequire(import.meta.url);
-  const serverTTS = r('webtalk/server-tts');
-  return serverTTS.ensureInstalled(onProgress);
-}
-export async function getSpeech() {
-  if (!speechModule) speechModule = await import('./speech.js');
-  return speechModule;
-}
-const ttsTextAccumulators = new Map();
-
-export const voiceCacheManager = {
-  generating: new Map(),
-  maxCacheSize: 10 * 1024 * 1024,
-  async getOrGenerateCache(conversationId, text) {
-    const cacheKey = `${conversationId}:${text}`;
-    if (this.generating.has(cacheKey)) {
-      return new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          const cached = _queries.getVoiceCache(conversationId, text);
-          if (cached) { clearInterval(checkInterval); resolve(cached); }
-        }, 50);
-      });
-    }
-    const cached = _queries.getVoiceCache(conversationId, text);
-    if (cached) return cached;
-    this.generating.set(cacheKey, true);
-    try {
-      const speech = await getSpeech();
-      const audioBlob = await speech.synthesize(text, 'default');
-      const saved = _queries.saveVoiceCache(conversationId, text, audioBlob);
-      const totalSize = _queries.getVoiceCacheSize(conversationId);
-      if (totalSize > this.maxCacheSize) {
-        const needed = totalSize - this.maxCacheSize;
-        _queries.deleteOldestVoiceCache(conversationId, needed);
-      }
-      return saved;
-    } finally {
-      this.generating.delete(cacheKey);
-    }
-  }
-};
-export const modelDownloadState = {
-  downloading: false,
-  progress: null,
-  error: null,
-  complete: false,
-  startTime: null,
-  downloadMetrics: new Map(),
-  waiters: []
-};
-export function broadcastModelProgress(progress) {
-  modelDownloadState.progress = progress;
-  const broadcastData = {
-    type: 'model_download_progress',
-    modelId: progress.type || 'unknown',
-    bytesDownloaded: progress.bytesDownloaded || 0,
-    bytesRemaining: progress.bytesRemaining || 0,
-    totalBytes: progress.totalBytes || 0,
-    downloadSpeed: progress.downloadSpeed || 0,
-    eta: progress.eta || 0,
-    retryCount: progress.retryCount || 0,
-    currentGateway: progress.currentGateway || '',
-    status: progress.status || (progress.done ? 'completed' : progress.downloading ? 'downloading' : 'paused'),
-    percentComplete: progress.percentComplete || 0,
-    completedFiles: progress.completedFiles || 0,
-    totalFiles: progress.totalFiles || 0,
-    timestamp: Date.now(),
-    ...progress
-  };
-  _broadcastSync(broadcastData);
-}
-
-async function validateAndCleanupModels(modelsDir) {
-  try {
-    const manifestPath = path.join(modelsDir, '.manifests.json');
-    if (fs.existsSync(manifestPath)) {
-      try {
-        const content = fs.readFileSync(manifestPath, 'utf8');
-        JSON.parse(content);
-      } catch (e) {
-        console.error('[MODELS] Manifest corrupted, removing:', e.message);
-        fs.unlinkSync(manifestPath);
-      }
-    }
-    const files = fs.readdirSync(modelsDir);
-    for (const file of files) {
-      if (file.endsWith('.tmp')) {
-        try { fs.unlinkSync(path.join(modelsDir, file)); console.log('[MODELS] Cleaned up temp file:', file); }
-        catch (e) { console.warn('[MODELS] Failed to clean:', file); }
-      }
-    }
-  } catch (e) {
-    console.warn('[MODELS] Cleanup check failed:', e.message);
-  }
-}
-
-export async function ensureModelsDownloaded() {
-  if (modelDownloadState.downloading) {
-    return new Promise(resolve => { modelDownloadState.waiters.push(resolve); });
-  }
-  modelDownloadState.downloading = true;
-  modelDownloadState.error = null;
-  try {
-    const r = createRequire(import.meta.url);
-    const { createConfig } = r('webtalk/config');
-    const { ensureModel } = r('webtalk/whisper-models');
-    const { ensureTTSModels } = r('webtalk/tts-models');
-    const gmguiModels = path.join(os.homedir(), '.gmgui', 'models');
-    const modelsBase = process.env.PORTABLE_EXE_DIR
-      ? (fs.existsSync(path.join(process.env.PORTABLE_EXE_DIR, 'models', 'onnx-community')) ? path.join(process.env.PORTABLE_EXE_DIR, 'models') : gmguiModels)
-      : gmguiModels;
-    await validateAndCleanupModels(modelsBase);
-    const config = createConfig({ modelsDir: modelsBase, ttsModelsDir: path.join(modelsBase, 'tts') });
-    const onProgress = (progress) => { broadcastModelProgress({ ...progress, started: true, done: false, downloading: true }); };
-    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'whisper', status: 'starting' });
-    await ensureModel('onnx-community/whisper-base', config, onProgress);
-    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', status: 'starting' });
-    await ensureTTSModels(config, onProgress);
-    modelDownloadState.complete = true;
-    broadcastModelProgress({ started: true, done: true, complete: true, downloading: false });
-    return true;
-  } catch (err) {
-    console.error('[MODELS] Download error:', err.message);
-    modelDownloadState.error = err.message;
-    broadcastModelProgress({ done: true, error: err.message });
-    return false;
-  } finally {
-    modelDownloadState.downloading = false;
-    const result = modelDownloadState.complete;
-    for (const resolve of modelDownloadState.waiters) resolve(result);
-    modelDownloadState.waiters = [];
-  }
-}
-
-export function eagerTTS(text, conversationId, sessionId) {
-  const key = `${conversationId}:${sessionId}`;
-  let acc = ttsTextAccumulators.get(key);
-  if (!acc) { acc = { text: '', timer: null }; ttsTextAccumulators.set(key, acc); }
-  acc.text += text;
-  if (acc.timer) clearTimeout(acc.timer);
-  acc.timer = setTimeout(() => flushTTSaccumulator(key, conversationId, sessionId), 600);
-}
-
-function flushTTSaccumulator(key, conversationId, sessionId) {
-  const acc = ttsTextAccumulators.get(key);
-  if (!acc || !acc.text) return;
-  const text = acc.text.trim();
-  acc.text = '';
-  ttsTextAccumulators.delete(key);
-  getSpeech().then(speech => {
-    const status = speech.getStatus();
-    if (!status.ttsReady || status.ttsError) return;
-    const voices = new Set();
-    for (const ws of _syncClients) {
-      const vid = ws.ttsVoiceId || 'default';
-      const convKey = `conv-${conversationId}`;
-      if (ws.subscriptions && (ws.subscriptions.has(sessionId) || ws.subscriptions.has(convKey))) {
-        voices.add(vid);
-      }
-    }
-    if (voices.size === 0) return;
-    for (const vid of voices) {
-      const cacheKey = speech.ttsCacheKey(text, vid);
-      const cached = speech.ttsCacheGet(cacheKey);
-      if (cached) { pushTTSAudio(cacheKey, cached, conversationId, sessionId, vid); continue; }
-      speech.synthesize(text, vid).then(wav => {
-        if (speech.ttsCacheSet) speech.ttsCacheSet(cacheKey, wav);
-        pushTTSAudio(cacheKey, wav, conversationId, sessionId, vid);
-      }).catch(() => {});
-    }
-  }).catch(() => {});
-}
-
-function pushTTSAudio(cacheKey, wav, conversationId, sessionId, voiceId) {
-  const b64 = wav.toString('base64');
-  _broadcastSync({
-    type: 'tts_audio',
-    cacheKey,
-    audio: b64,
-    voiceId,
-    conversationId,
-    sessionId,
-    timestamp: Date.now()
-  });
-}

package/lib/speech.js

@@ -1,50 +0,0 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-const speech = require('webtalk/speech');
-
-const ttsMemCache = new Map();
-const TTS_CACHE_MAX_BYTES = 10 * 1024 * 1024;
-let ttsCacheBytes = 0;
-
-function ttsCacheKey(text, voiceId) {
-  return (voiceId || 'default') + ':' + text;
-}
-
-function ttsCacheGet(key) {
-  return ttsMemCache.get(key) || null;
-}
-
-function ttsCacheSet(key, wav) {
-  if (ttsMemCache.has(key)) return;
-  const size = wav ? wav.length : 0;
-  while (ttsCacheBytes + size > TTS_CACHE_MAX_BYTES && ttsMemCache.size > 0) {
-    const oldest = ttsMemCache.keys().next().value;
-    const old = ttsMemCache.get(oldest);
-    ttsCacheBytes -= old ? old.length : 0;
-    ttsMemCache.delete(oldest);
-  }
-  ttsMemCache.set(key, wav);
-  ttsCacheBytes += size;
-}
-
-async function synthesizeWithCache(text, voiceId) {
-  const key = ttsCacheKey(text, voiceId);
-  const cached = ttsCacheGet(key);
-  if (cached) return cached;
-  const wav = await speech.synthesize(text, voiceId);
-  ttsCacheSet(key, wav);
-  return wav;
-}
-
-export const transcribe = speech.transcribe;
-export const synthesize = synthesizeWithCache;
-export const synthesizeStream = speech.synthesizeStream;
-export const getSTT = speech.getSTT;
-export const getStatus = speech.getStatus;
-export const getVoices = speech.getVoices;
-export const preloadTTS = speech.preloadTTS;
-export { ttsCacheKey, ttsCacheGet, ttsCacheSet };
-export const resetSTTError = speech.resetSTTError;
-export const clearCorruptedSTTCache = speech.clearCorruptedSTTCache;
-export const getSttOptions = speech.getSttOptions;
-export const VOICE_DIRS = speech.VOICE_DIRS;

package/lib/tool-install-machine.js

@@ -1,157 +0,0 @@
-import { createMachine, createActor, assign } from 'xstate';
-
-const machine = createMachine({
-  id: 'tool-install',
-  initial: 'unchecked',
-  context: {
-    version: null,
-    error: null,
-    installedAt: null,
-    lastCheckedAt: null,
-  },
-  states: {
-    unchecked: {
-      on: {
-        CHECK_START: 'checking',
-        INSTALL_START: 'installing',
-      },
-    },
-    checking: {
-      entry: assign({ lastCheckedAt: () => Date.now() }),
-      on: {
-        IDLE: {
-          target: 'idle',
-          actions: assign(({ event }) => ({
-            version: event.version || null,
-            lastCheckedAt: Date.now(),
-          })),
-        },
-        INSTALLED: {
-          target: 'installed',
-          actions: assign(({ event }) => ({
-            version: event.version || null,
-            installedAt: event.installedAt || Date.now(),
-            lastCheckedAt: Date.now(),
-          })),
-        },
-        NEEDS_UPDATE: {
-          target: 'needs_update',
-          actions: assign(({ event }) => ({
-            version: event.version || null,
-            lastCheckedAt: Date.now(),
-          })),
-        },
-        FAILED: {
-          target: 'failed',
-          actions: assign(({ event }) => ({ error: event.error || 'check failed' })),
-        },
-      },
-    },
-    idle: {
-      on: {
-        CHECK_START: 'checking',
-        INSTALL_START: 'installing',
-      },
-    },
-    installing: {
-      entry: assign({ error: null }),
-      on: {
-        INSTALL_COMPLETE: {
-          target: 'installed',
-          actions: assign(({ event }) => ({
-            version: event.version || null,
-            installedAt: Date.now(),
-            error: null,
-          })),
-        },
-        FAILED: {
-          target: 'failed',
-          actions: assign(({ event }) => ({ error: event.error || 'install failed' })),
-        },
-      },
-    },
-    installed: {
-      on: {
-        CHECK_START: 'checking',
-        UPDATE_START: 'updating',
-      },
-    },
-    updating: {
-      entry: assign({ error: null }),
-      on: {
-        UPDATE_COMPLETE: {
-          target: 'installed',
-          actions: assign(({ event }) => ({
-            version: event.version || null,
-            error: null,
-          })),
-        },
-        FAILED: {
-          target: 'failed',
-          actions: assign(({ event }) => ({ error: event.error || 'update failed' })),
-        },
-      },
-    },
-    needs_update: {
-      on: {
-        UPDATE_START: 'updating',
-        CHECK_START: 'checking',
-      },
-    },
-    failed: {
-      on: {
-        CHECK_START: 'checking',
-        INSTALL_START: 'installing',
-      },
-    },
-  },
-});
-
-const actors = new Map();
-
-export function getOrCreate(toolId) {
-  if (actors.has(toolId)) return actors.get(toolId);
-  const actor = createActor(machine);
-  actor.start();
-  actors.set(toolId, actor);
-  return actor;
-}
-
-export function get(toolId) {
-  return actors.get(toolId) || null;
-}
-
-export function send(toolId, event) {
-  const actor = getOrCreate(toolId);
-  actor.send(event);
-  return actor.getSnapshot();
-}
-
-export function snapshot(toolId) {
-  const actor = actors.get(toolId);
-  return actor ? actor.getSnapshot() : null;
-}
-
-export function isLocked(toolId) {
-  const s = snapshot(toolId);
-  return s ? (s.value === 'installing' || s.value === 'updating') : false;
-}
-
-export function getState(toolId) {
-  const s = snapshot(toolId);
-  return s ? s.value : 'unchecked';
-}
-
-export function remove(toolId) {
-  const actor = actors.get(toolId);
-  if (actor) { actor.stop(); actors.delete(toolId); }
-}
-
-export function stopAll() {
-  for (const [, actor] of actors) actor.stop();
-  actors.clear();
-}
-
-export function getMachineActors() {
-  return actors;
-}

package/lib/tool-manager.js

@@ -1,98 +0,0 @@
-import { checkToolViaBunx, clearVersionCache } from './tool-version-fetch.js';
-import { createInstaller } from './tool-spawner.js';
-import { autoProvision as _autoProvision, startPeriodicUpdateCheck as _startPeriodicUpdateCheck, stopPeriodicUpdateCheck } from './tool-provisioner.js';
-
-const TOOLS = [
-  { id: 'cli-claude', name: 'Claude Code', pkg: '@anthropic-ai/claude-code', category: 'cli' },
-  { id: 'cli-opencode', name: 'OpenCode', pkg: 'opencode-ai', category: 'cli' },
-  { id: 'cli-gemini', name: 'Gemini CLI', pkg: '@google/gemini-cli', category: 'cli' },
-  { id: 'cli-kilo', name: 'Kilo Code', pkg: '@kilocode/cli', category: 'cli' },
-  { id: 'cli-codex', name: 'Codex CLI', pkg: '@openai/codex', category: 'cli' },
-  { id: 'cli-agent-browser', name: 'Agent Browser', pkg: 'agent-browser', category: 'cli' },
-  { id: 'gm-cc', name: 'GM Claude', pkg: 'gm-cc', installPkg: 'gm-cc@latest', pluginId: 'gm-cc', category: 'plugin', frameWork: 'claude' },
-  { id: 'gm-oc', name: 'GM OpenCode', pkg: 'gm-oc', installPkg: 'gm-oc@latest', pluginId: 'gm', category: 'plugin', frameWork: 'opencode' },
-  { id: 'gm-gc', name: 'GM Gemini', pkg: 'gm-gc', installPkg: 'gm-gc@latest', pluginId: 'gm', category: 'plugin', frameWork: 'gemini' },
-  { id: 'gm-kilo', name: 'GM Kilo', pkg: 'gm-kilo', installPkg: 'gm-kilo@latest', pluginId: 'gm', category: 'plugin', frameWork: 'kilo' },
-  { id: 'gm-codex', name: 'GM Codex', pkg: 'gm-codex', installPkg: 'gm-codex@latest', pluginId: 'gm', category: 'plugin', frameWork: 'codex' },
-];
-
-const statusCache = new Map();
-
-const getTool = (id) => TOOLS.find(t => t.id === id);
-
-export function checkToolStatus(toolId) {
-  const tool = getTool(toolId);
-  if (!tool) return null;
-  const cached = statusCache.get(toolId);
-  if (cached && Date.now() - cached.timestamp < 1800000) {
-    return { toolId, installed: cached.installed, isUpToDate: cached.isUpToDate, upgradeNeeded: cached.upgradeNeeded, timestamp: cached.timestamp };
-  }
-  return { toolId, installed: false, isUpToDate: false, upgradeNeeded: false, timestamp: Date.now() };
-}
-
-export async function checkToolStatusAsync(toolId, skipPublishedVersion = true) {
-  const tool = getTool(toolId);
-  if (!tool) return null;
-  const cached = statusCache.get(toolId);
-  if (cached && Date.now() - cached.timestamp < 1800000) {
-    return { toolId, installed: cached.installed, isUpToDate: cached.isUpToDate, upgradeNeeded: cached.upgradeNeeded, installedVersion: cached.installedVersion, publishedVersion: cached.publishedVersion, timestamp: cached.timestamp };
-  }
-  const result = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, skipPublishedVersion, TOOLS);
-  const status = { toolId, category: tool.category, installed: result.installed, isUpToDate: result.isUpToDate, upgradeNeeded: result.upgradeNeeded, installedVersion: result.installedVersion, publishedVersion: result.publishedVersion, timestamp: Date.now() };
-  statusCache.set(toolId, status);
-  return status;
-}
-
-export async function checkForUpdates(toolId) {
-  const tool = getTool(toolId);
-  if (!tool) return { needsUpdate: false };
-  const status = await checkToolStatusAsync(toolId);
-  return { needsUpdate: status.upgradeNeeded && status.installed };
-}
-
-const { install, update } = createInstaller(getTool, statusCache, checkToolStatusAsync);
-export { install, update };
-
-export function getAllTools() {
-  return TOOLS.map(tool => {
-    const cached = statusCache.get(tool.id);
-    return { ...tool, toolId: tool.id, installed: cached?.installed ?? false, isUpToDate: cached?.isUpToDate ?? false, upgradeNeeded: cached?.upgradeNeeded ?? false, installedVersion: cached?.installedVersion ?? null, publishedVersion: cached?.publishedVersion ?? null, timestamp: cached?.timestamp ?? 0 };
-  });
-}
-
-export async function getAllToolsAsync(skipPublishedVersion = false) {
-  const results = await Promise.all(TOOLS.map(tool => checkToolStatusAsync(tool.id, skipPublishedVersion)));
-  return results.map((status, idx) => ({ ...TOOLS[idx], ...status }));
-}
-
-export function clearStatusCache() {
-  statusCache.clear();
-  clearVersionCache();
-  console.log('[tool-manager] Caches cleared, forcing fresh tool detection');
-}
-
-export async function refreshAllToolsAsync() {
-  clearStatusCache();
-  return getAllToolsAsync();
-}
-
-export function getAllToolsSync() {
-  return TOOLS.map(tool => {
-    const cached = statusCache.get(tool.id);
-    return { ...tool, ...cached };
-  });
-}
-
-export function getToolConfig(toolId) {
-  return getTool(toolId) || null;
-}
-
-export async function autoProvision(broadcast) {
-  return _autoProvision(TOOLS, statusCache, install, broadcast);
-}
-
-export function startPeriodicUpdateCheck(broadcast) {
-  return _startPeriodicUpdateCheck(TOOLS, statusCache, update, broadcast);
-}
-
-export { stopPeriodicUpdateCheck };

package/lib/tool-provisioner.js

@@ -1,98 +0,0 @@
-import { checkToolViaBunx } from './tool-version-fetch.js';
-import * as toolInstallMachine from './tool-install-machine.js';
-
-let updateCheckInterval = null;
-const UPDATE_CHECK_INTERVAL = 6 * 60 * 60 * 1000;
-
-export async function autoProvision(TOOLS, statusCache, install, broadcast) {
-  const log = (msg) => console.log('[TOOLS-AUTO] ' + msg);
-  log('Starting background tool provisioning...');
-  for (const tool of TOOLS) {
-    try {
-      toolInstallMachine.send(tool.id, { type: 'CHECK_START' });
-      const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, true, TOOLS);
-      statusCache.set(tool.id, { ...status, toolId: tool.id, timestamp: Date.now() });
-      if (!status.installed) {
-        toolInstallMachine.send(tool.id, { type: 'IDLE' });
-        log(`${tool.id} not installed, installing...`);
-        broadcast({ type: 'tool_install_started', toolId: tool.id });
-        const result = await install(tool.id, (msg) => {
-          broadcast({ type: 'tool_install_progress', toolId: tool.id, data: msg });
-        });
-        if (result.success) {
-          log(`${tool.id} installed v${result.version}`);
-          broadcast({ type: 'tool_install_complete', toolId: tool.id, data: result });
-        } else {
-          log(`${tool.id} install failed: ${result.error}`);
-          broadcast({ type: 'tool_install_failed', toolId: tool.id, data: result });
-        }
-      } else if (status.upgradeNeeded) {
-        toolInstallMachine.send(tool.id, { type: 'NEEDS_UPDATE', version: status.installedVersion });
-        log(`${tool.id} needs update (${status.installedVersion} -> ${status.publishedVersion})`);
-        broadcast({ type: 'tool_install_started', toolId: tool.id });
-        const result = await install(tool.id, (msg) => {
-          broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
-        });
-        if (result.success) {
-          log(`${tool.id} updated to v${result.version}`);
-          broadcast({ type: 'tool_update_complete', toolId: tool.id, data: result });
-        } else {
-          log(`${tool.id} update failed: ${result.error}`);
-          broadcast({ type: 'tool_update_failed', toolId: tool.id, data: result });
-        }
-      } else {
-        toolInstallMachine.send(tool.id, { type: 'INSTALLED', version: status.installedVersion });
-        log(`${tool.id} v${status.installedVersion || 'unknown'} up-to-date`);
-        broadcast({ type: 'tool_status_update', toolId: tool.id, data: { installed: true, isUpToDate: true, installedVersion: status.installedVersion, status: 'installed' } });
-      }
-    } catch (err) {
-      toolInstallMachine.send(tool.id, { type: 'FAILED', error: err.message });
-      log(`${tool.id} error: ${err.message}`);
-    }
-  }
-  log('Provisioning complete');
-}
-
-export function startPeriodicUpdateCheck(TOOLS, statusCache, update, broadcast) {
-  const log = (msg) => console.log('[TOOLS-PERIODIC] ' + msg);
-  if (updateCheckInterval) { log('Update check already running'); return; }
-  log('Starting periodic tool update checker (every 6 hours)');
-
-  const check = async () => {
-    log('Checking for tool updates...');
-    for (const tool of TOOLS) {
-      try {
-        const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, false, TOOLS);
-        if (status.upgradeNeeded) {
-          log(`Update available for ${tool.id}: ${status.installedVersion} -> ${status.publishedVersion}`);
-          broadcast({ type: 'tool_update_available', toolId: tool.id, data: { installedVersion: status.installedVersion, publishedVersion: status.publishedVersion } });
-          log(`Auto-updating ${tool.id}...`);
-          const result = await update(tool.id, (msg) => {
-            broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
-          });
-          if (result.success) {
-            log(`${tool.id} auto-updated to v${result.version}`);
-            broadcast({ type: 'tool_update_complete', toolId: tool.id, data: { ...result, autoUpdated: true } });
-          } else {
-            log(`${tool.id} auto-update failed: ${result.error}`);
-            broadcast({ type: 'tool_update_failed', toolId: tool.id, data: { ...result, autoUpdated: true } });
-          }
-        }
-      } catch (err) {
-        log(`Error checking ${tool.id}: ${err.message}`);
-      }
-    }
-    log('Update check complete');
-  };
-
-  setImmediate(() => check().catch(err => log(`Initial check failed: ${err.message}`)));
-  updateCheckInterval = setInterval(() => check().catch(err => log(`Periodic check failed: ${err.message}`)), UPDATE_CHECK_INTERVAL);
-}
-
-export function stopPeriodicUpdateCheck() {
-  if (updateCheckInterval) {
-    clearInterval(updateCheckInterval);
-    updateCheckInterval = null;
-    console.log('[TOOLS-PERIODIC] Update check stopped');
-  }
-}