@zhangferry-dev/tokendash 1.6.1 → 1.7.0

package/electron/main.cjs

@@ -1,516 +0,0 @@
-const { app, BrowserWindow, ipcMain, screen, shell } = require('electron');
-const path = require('node:path');
-const fs = require('node:fs');
-const http = require('node:http');
-const { spawn } = require('node:child_process');
-
-// Global debug logger (writes to file since stdout is lost in packaged apps)
-const DEBUG_LOG = '/tmp/tokendash-debug.log';
-try { fs.writeFileSync(DEBUG_LOG, 'main.js loaded\n'); } catch(_){}
-
-// Import from bundled server (created by esbuild)
-let createApp;
-try {
-  createApp = require('../dist/electron-server.cjs').createApp;
-} catch (e) {
-  console.error('Failed to load bundled server. Did you run the build?', e.message);
-  app.quit();
-}
-
-const { formatTokens } = require('./trayBadge.cjs');
-const { checkForUpdates, downloadUpdateAsset } = require('./updateService.cjs');
-const { syncNpmPackageVersion } = require('./npmSync.cjs');
-const { findCompatibleServer, getDashboardUrl } = require('./serverReuse.cjs');
-
-// Resolve trayHelper binary: extract from asar if needed
-function resolveTrayHelperPath() {
-  const srcPath = path.join(__dirname, 'trayHelper');
-  const isAsar = srcPath.includes('.asar');
-  const debugLog = (msg) => {
-    const logPath = '/tmp/tokendash-debug.log';
-    fs.appendFileSync(logPath, msg + '\n');
-  };
-  debugLog('[trayHelper] __dirname: ' + __dirname);
-  debugLog('[trayHelper] srcPath: ' + srcPath + ' isAsar: ' + isAsar);
-  if (isAsar) {
-    const destDir = path.join(app.getPath('userData'), 'helpers');
-    const destPath = path.join(destDir, 'trayHelper');
-    debugLog('[trayHelper] extracting to: ' + destPath);
-    if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
-    fs.copyFileSync(srcPath, destPath);
-    fs.chmodSync(destPath, 0o755);
-    debugLog('[trayHelper] extracted OK');
-    return destPath;
-  }
-  return srcPath;
-}
-
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-
-let popover = null;
-let server = null;
-let trayProcess = null;
-let selectedAgents = null; // null = use all available agents
-let serverPort = parseInt(process.env.TOKENDASH_PORT || '3456', 10);
-let dashboardUrl = getDashboardUrl(serverPort);
-let lastUpdateInfo = null;
-let isDownloadingUpdate = false;
-const POPOVER_WIDTH = 380;
-const POPOVER_HEIGHT = 540;
-const PACKAGE_NAME = '@zhangferry-dev/tokendash';
-const GITHUB_REPO = 'zhangferry/tokendash';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function listenWithFallback(expressApp, port) {
-  return new Promise((resolve, reject) => {
-    let currentPort = port;
-    let attempts = 0;
-
-    function tryListen() {
-      const s = expressApp.listen(currentPort);
-      s.once('listening', () => resolve({ server: s, port: currentPort }));
-      s.once('error', (err) => {
-        if (err.code === 'EADDRINUSE' && attempts < 20) {
-          attempts++;
-          currentPort++;
-          tryListen();
-        } else {
-          reject(err);
-        }
-      });
-    }
-
-    tryListen();
-  });
-}
-
-function fetchJson(url) {
-  return new Promise((resolve, reject) => {
-    http.get(url, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try { resolve(JSON.parse(data)); }
-        catch (e) { reject(e); }
-      });
-    }).on('error', reject);
-  });
-}
-
-function getServerBaseUrl() {
-  return dashboardUrl || getDashboardUrl(serverPort);
-}
-
-function getAppInfo() {
-  // app.getVersion() returns Electron's version in dev mode (e.g. 41.5).
-  // Always read from package.json to get the app's own version.
-  let version = app.getVersion();
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
-    if (pkg.version) version = pkg.version;
-  } catch (_) {}
-  return {
-    version,
-    launchAtLogin: app.getLoginItemSettings().openAtLogin,
-    platform: process.platform,
-    packageName: PACKAGE_NAME,
-  };
-}
-
-function positionPopoverAtClick(clickScreenX) {
-  if (!popover) return;
-
-  // Find which display the click is on
-  const allDisplays = screen.getAllDisplays();
-  const clickDisplay = allDisplays.find(d => {
-    const bounds = d.bounds;
-    return clickScreenX >= bounds.x && clickScreenX < bounds.x + bounds.width;
-  }) || screen.getPrimaryDisplay();
-
-  const { x: screenX, y: screenY, width: screenW, height: screenH } = clickDisplay.workArea;
-  const popoverWidth = POPOVER_WIDTH;
-  const popoverHeight = POPOVER_HEIGHT;
-
-  // Center horizontally on click position
-  let x = clickScreenX - popoverWidth / 2;
-  // Below menu bar, close to the icon
-  let y = screenY + 6;
-
-  // Clamp to screen bounds
-  if (x < screenX + 8) x = screenX + 8;
-  if (x + popoverWidth > screenX + screenW - 8) x = screenX + screenW - popoverWidth - 8;
-  if (y + popoverHeight > screenY + screenH - 8) y = screenY + screenH - popoverHeight - 8;
-
-  popover.setPosition(Math.round(x), Math.round(y), false);
-}
-
-function togglePopover(clickScreenX) {
-  if (!popover) return;
-
-  if (popover.isVisible()) {
-    popover.hide();
-  } else {
-    positionPopoverAtClick(clickScreenX || 0);
-    popover.show();
-    popover.focus();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Native tray helper (Swift binary for macOS 26+ compatibility)
-// ---------------------------------------------------------------------------
-
-function startTrayHelper() {
-  const helperPath = resolveTrayHelperPath();
-  trayProcess = spawn(helperPath, [], {
-    stdio: ['pipe', 'pipe', 'inherit'],
-  });
-
-  let buffer = '';
-
-  trayProcess.stdout.on('data', (data) => {
-    buffer += data.toString();
-    const lines = buffer.split('\n');
-    buffer = lines.pop(); // keep incomplete line in buffer
-
-    for (const line of lines) {
-      const event = line.trim();
-      if (event.startsWith('click:')) {
-        // Format: click:x,y (screen coordinates in macOS points)
-        const parts = event.split(':')[1];
-        const clickX = parseInt(parts.split(',')[0], 10) || 0;
-        // Convert macOS screen coords (origin bottom-left) to top-left for Electron
-        const primaryDisplay = screen.getPrimaryDisplay();
-        const screenH = primaryDisplay.size.height;
-        togglePopover(clickX);
-      } else if (event === 'ready') {
-        // Helper is ready, start badge updates
-        startBadgeUpdates();
-      }
-    }
-  });
-
-  trayProcess.on('close', (code) => {
-    console.log('Tray helper exited with code', code);
-    trayProcess = null;
-  });
-
-  trayProcess.on('error', (err) => {
-    console.error('Failed to start tray helper:', err.message);
-    trayProcess = null;
-  });
-}
-
-function sendTrayCommand(command) {
-  if (trayProcess && trayProcess.stdin && !trayProcess.stdin.destroyed) {
-    trayProcess.stdin.write(command + '\n');
-  }
-}
-
-function stopTrayHelper() {
-  if (trayProcess) {
-    sendTrayCommand('quit');
-    trayProcess = null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tray badge updater
-// ---------------------------------------------------------------------------
-
-let updateTimer = null;
-let lastTraySnapshot = null;
-
-function getTrayAgentKey(agents) {
-  return agents.slice().sort().join(',');
-}
-
-function applyTraySnapshot(snapshot) {
-  const totalTokens = Number(snapshot && snapshot.totalTokens) || 0;
-  const totalInput = Number(snapshot && snapshot.totalInput) || 0;
-  const totalCost = Number(snapshot && snapshot.totalCost) || 0;
-  const totalCacheRead = Number(snapshot && snapshot.totalCacheRead) || 0;
-  const today = snapshot && snapshot.today;
-  const agentKey = snapshot && snapshot.agentKey;
-
-  lastTraySnapshot = { today, agentKey, totalTokens, totalInput, totalCost, totalCacheRead };
-
-  const tokenStr = formatTokens(totalTokens);
-  sendTrayCommand('title:' + tokenStr);
-
-  const cacheInput = totalInput + totalCacheRead;
-  const cacheRate = cacheInput > 0 ? ((totalCacheRead / cacheInput) * 100).toFixed(1) : '0.0';
-  sendTrayCommand('tooltip:TokenDash - ' + tokenStr + ' tokens today ($' + totalCost.toFixed(2) + ') | cache: ' + cacheRate + '%');
-}
-
-function updateTrayBadge() {
-  const d = new Date(); const today = d.getFullYear() + "-" + String(d.getMonth()+1).padStart(2,"0") + "-" + String(d.getDate()).padStart(2,"0");
-
-  // Fetch agents list, then fetch daily data for each agent in parallel
-  const serverBaseUrl = getServerBaseUrl();
-  fetchJson(`${serverBaseUrl}/api/agents`)
-    .then((agentData) => {
-      let agents = (agentData && Array.isArray(agentData.available)) ? agentData.available : ['claude'];
-      if (agents.length === 0) {
-        // Transient agent detection failures should not clear a previously valid tray badge.
-        return null;
-      }
-
-      // Apply agent filter from popover settings
-      if (selectedAgents && selectedAgents.length > 0) {
-        const filtered = agents.filter(a => selectedAgents.includes(a));
-        if (filtered.length > 0) agents = filtered;
-      }
-
-      const agentKey = getTrayAgentKey(agents);
-      return Promise.all(
-        agents.map(agent =>
-          fetchJson(`${serverBaseUrl}/api/daily?agent=${agent}`)
-            .catch(() => null)
-        )
-      ).then(results => ({ agentKey, results }));
-    })
-    .then((payload) => {
-      if (!payload) return;
-      const { agentKey, results } = payload;
-      const successfulResults = results.filter(data => data && data.daily);
-      if (successfulResults.length === 0) {
-        // Keep the last good value when every daily request failed.
-        return;
-      }
-
-      let totalTokens = 0;
-      let totalCost = 0;
-      let totalInput = 0;
-      let totalOutput = 0;
-      let totalCacheRead = 0;
-
-      for (const data of results) {
-        if (!data || !data.daily) continue;
-        const entry = data.daily.find(d => d.date === today);
-        if (!entry) continue;
-        totalTokens += entry.totalTokens || 0;
-        totalCost += entry.totalCost || 0;
-        totalInput += entry.inputTokens || 0;
-        totalOutput += entry.outputTokens || 0;
-        totalCacheRead += entry.cacheReadTokens || 0;
-      }
-
-      const shouldPreserveLastPositive =
-        totalTokens === 0 &&
-        lastTraySnapshot &&
-        lastTraySnapshot.today === today &&
-        lastTraySnapshot.agentKey === agentKey &&
-        lastTraySnapshot.totalTokens > 0;
-
-      if (shouldPreserveLastPositive) {
-        // Daily usage should not drop to zero during the same day for the same agent filter.
-        // Treat a zero refresh after a positive value as transient empty data and keep the badge stable.
-        return;
-      }
-
-      applyTraySnapshot({ today, agentKey, totalTokens, totalInput, totalCost, totalCacheRead });
-    })
-    .catch((err) => {
-      if (err.code !== 'ECONNREFUSED') {
-        console.error('Tray badge update error:', err.message);
-      }
-    });
-}
-
-function startBadgeUpdates() {
-  updateTrayBadge();
-  updateTimer = setInterval(updateTrayBadge, 5000);
-}
-
-function stopBadgeUpdates() {
-  if (updateTimer) {
-    clearInterval(updateTimer);
-    updateTimer = null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Create popover window
-// ---------------------------------------------------------------------------
-
-function createPopoverWindow() {
-  popover = new BrowserWindow({
-    width: POPOVER_WIDTH,
-    height: POPOVER_HEIGHT,
-    frame: false,
-    resizable: false,
-    hasShadow: true,
-    alwaysOnTop: true,
-    skipTaskbar: true,
-    show: false,
-    fullscreenable: false,
-    transparent: false,
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      preload: path.join(__dirname, 'preload.cjs'),
-    },
-  });
-
-  popover.loadURL(`${getServerBaseUrl()}/popover.html`);
-
-  popover.on('blur', () => {
-    popover.hide();
-  });
-
-  popover.on('close', (e) => {
-    if (!app.isQuitting) {
-      e.preventDefault();
-      popover.hide();
-    }
-  });
-}
-
-function registerIpcHandlers() {
-  ipcMain.handle('tokendash:open-dashboard', (_event, url) => {
-    return shell.openExternal(getServerBaseUrl());
-  });
-
-  ipcMain.handle('tokendash:get-app-info', () => {
-    return getAppInfo();
-  });
-
-  ipcMain.handle('tokendash:set-launch-at-login', (_event, enabled) => {
-    const openAtLogin = Boolean(enabled);
-    app.setLoginItemSettings({ openAtLogin });
-    return { launchAtLogin: app.getLoginItemSettings().openAtLogin };
-  });
-
-  ipcMain.handle('tokendash:check-for-updates', async () => {
-    const currentVersion = getAppInfo().version;
-
-    try {
-      lastUpdateInfo = await checkForUpdates({ repo: GITHUB_REPO, currentVersion });
-      return lastUpdateInfo;
-    } catch (error) {
-      return {
-        currentVersion,
-        latestVersion: currentVersion,
-        upToDate: true,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  });
-
-  ipcMain.handle('tokendash:download-update', async (event) => {
-    if (isDownloadingUpdate) {
-      return { ok: false, error: 'An update download is already in progress.' };
-    }
-
-    const info = lastUpdateInfo;
-    if (!info || info.upToDate || !info.asset || !info.asset.url) {
-      return { ok: false, error: 'No downloadable update is available.' };
-    }
-
-    isDownloadingUpdate = true;
-    try {
-      const downloadsDir = path.join(app.getPath('downloads'), 'TokenDash Updates');
-      const filePath = await downloadUpdateAsset(info.asset, downloadsDir, (progress) => {
-        event.sender.send('tokendash:update-download-progress', progress);
-      });
-      await shell.openPath(filePath);
-      return { ok: true, filePath };
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    } finally {
-      isDownloadingUpdate = false;
-    }
-  });
-
-  ipcMain.handle('tokendash:quit', () => {
-    app.isQuitting = true;
-    stopBadgeUpdates();
-    stopTrayHelper();
-    if (server) server.close();
-    app.quit();
-  });
-
-  ipcMain.handle('tokendash:set-selected-agents', (_event, agents) => {
-    selectedAgents = Array.isArray(agents) ? agents : null;
-    lastTraySnapshot = null;
-    // Immediately refresh badge with new filter
-    updateTrayBadge();
-    return { ok: true };
-  });
-
-  ipcMain.handle('tokendash:update-tray-snapshot', (_event, snapshot) => {
-    if (!snapshot || typeof snapshot !== 'object') return { ok: false };
-    applyTraySnapshot(snapshot);
-    return { ok: true };
-  });
-}
-
-// ---------------------------------------------------------------------------
-// App lifecycle
-// ---------------------------------------------------------------------------
-
-app.whenReady().then(async () => {
-  if (process.platform === 'darwin' && app.dock) {
-    app.dock.hide();
-  }
-
-  registerIpcHandlers();
-
-  app.on('before-quit', () => {
-    app.isQuitting = true;
-    stopBadgeUpdates();
-    stopTrayHelper();
-    if (server) server.close();
-  });
-
-  const currentVersion = getAppInfo().version;
-  syncNpmPackageVersion(PACKAGE_NAME, currentVersion).then((result) => {
-    if (!result || result.ok) return;
-    console.warn('Could not sync npm package version:', result.error || 'unknown error');
-  }).catch((error) => {
-    console.warn('Could not sync npm package version:', error instanceof Error ? error.message : String(error));
-  });
-
-  const existingServer = await findCompatibleServer(serverPort, currentVersion, PACKAGE_NAME);
-  if (existingServer) {
-    serverPort = existingServer.port;
-    dashboardUrl = existingServer.dashboardUrl;
-    console.log(`tokendash reusing CLI server on ${dashboardUrl}`);
-    startTrayHelper();
-    createPopoverWindow();
-    return;
-  }
-
-  // Create and bind Express server.
-  // Pass dist/ directory so createApp resolves client assets correctly.
-  const distDir = path.join(__dirname, '..', 'dist');
-  const expressApp = createApp(serverPort, distDir);
-  try {
-    const result = await listenWithFallback(expressApp, serverPort);
-    server = result.server;
-    serverPort = result.port;
-    dashboardUrl = getDashboardUrl(result.port);
-    console.log(`tokendash running on ${dashboardUrl}`);
-  } catch (err) {
-    console.error('Failed to start server:', err);
-    app.quit();
-    return;
-  }
-
-  // Start native tray helper
-  startTrayHelper();
-
-  // Create popover
-  createPopoverWindow();
-});
-
-process.on('uncaughtException', (err) => {
-  console.error('Fatal error in Electron main:', err);
-  app.quit();
-});

package/electron/npmSync.cjs

@@ -1,62 +0,0 @@
-const { spawn } = require('node:child_process');
-
-function normalizeVersion(version) {
-  return String(version || '').trim().replace(/^v/, '');
-}
-
-function shouldInstallPackage(installedVersion, targetVersion) {
-  const installed = normalizeVersion(installedVersion);
-  const target = normalizeVersion(targetVersion);
-  return Boolean(target) && installed !== target;
-}
-
-function buildNpmInstallArgs(packageName, version) {
-  return ['install', '-g', `${packageName}@${version}`];
-}
-
-function runCommand(command, args) {
-  return new Promise((resolve) => {
-    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
-    child.on('error', (error) => resolve({ ok: false, stdout, stderr, error }));
-    child.on('close', (code) => resolve({ ok: code === 0, code, stdout, stderr }));
-  });
-}
-
-async function getInstalledPackageVersion(packageName) {
-  const result = await runCommand('npm', ['list', '-g', packageName, '--depth=0', '--json']);
-  if (!result.ok) return null;
-  try {
-    const data = JSON.parse(result.stdout);
-    return normalizeVersion(data && data.dependencies && data.dependencies[packageName] && data.dependencies[packageName].version);
-  } catch (_) {
-    return null;
-  }
-}
-
-async function syncNpmPackageVersion(packageName, version) {
-  const installedVersion = await getInstalledPackageVersion(packageName);
-  if (!shouldInstallPackage(installedVersion, version)) {
-    return { ok: true, installedVersion, targetVersion: version, changed: false };
-  }
-
-  const result = await runCommand('npm', buildNpmInstallArgs(packageName, version));
-  return {
-    ok: result.ok,
-    installedVersion,
-    targetVersion: version,
-    changed: result.ok,
-    error: result.ok ? null : (result.error ? result.error.message : result.stderr || `npm exited with ${result.code}`),
-  };
-}
-
-module.exports = {
-  buildNpmInstallArgs,
-  getInstalledPackageVersion,
-  shouldInstallPackage,
-  syncNpmPackageVersion,
-};

package/electron/preload.cjs

@@ -1,36 +0,0 @@
-const { contextBridge, ipcRenderer } = require('electron');
-
-contextBridge.exposeInMainWorld('electronAPI', {
-  openDashboard(url) {
-    return ipcRenderer.invoke('tokendash:open-dashboard', url);
-  },
-  getAppInfo() {
-    return ipcRenderer.invoke('tokendash:get-app-info');
-  },
-  setLaunchAtLogin(enabled) {
-    return ipcRenderer.invoke('tokendash:set-launch-at-login', enabled);
-  },
-  checkForUpdates() {
-    return ipcRenderer.invoke('tokendash:check-for-updates');
-  },
-  downloadUpdate(updateInfo) {
-    return ipcRenderer.invoke('tokendash:download-update', updateInfo);
-  },
-  onUpdateDownloadProgress(callback) {
-    if (typeof callback !== 'function') return function noop() {};
-    const listener = (_event, progress) => callback(progress);
-    ipcRenderer.on('tokendash:update-download-progress', listener);
-    return function unsubscribe() {
-      ipcRenderer.removeListener('tokendash:update-download-progress', listener);
-    };
-  },
-  quitApp() {
-    return ipcRenderer.invoke('tokendash:quit');
-  },
-  setSelectedAgents(agents) {
-    return ipcRenderer.invoke('tokendash:set-selected-agents', agents);
-  },
-  updateTraySnapshot(snapshot) {
-    return ipcRenderer.invoke('tokendash:update-tray-snapshot', snapshot);
-  },
-});

package/electron/serverReuse.cjs

@@ -1,59 +0,0 @@
-const http = require('node:http');
-
-function normalizePort(port) {
-  const value = parseInt(String(port || ''), 10);
-  return Number.isInteger(value) && value > 0 ? value : 3456;
-}
-
-function getDashboardUrl(port) {
-  return `http://localhost:${normalizePort(port)}`;
-}
-
-function isCompatibleServerInfo(info, expectedVersion, expectedPackageName) {
-  return Boolean(
-    info &&
-    info.packageName === expectedPackageName &&
-    String(info.version || '').replace(/^v/, '') === String(expectedVersion || '').replace(/^v/, '')
-  );
-}
-
-function fetchJson(url, timeoutMs = 1000) {
-  return new Promise((resolve, reject) => {
-    const req = http.get(url, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        if (res.statusCode && res.statusCode >= 400) {
-          reject(new Error(`HTTP ${res.statusCode}`));
-          return;
-        }
-        try { resolve(JSON.parse(data)); }
-        catch (error) { reject(error); }
-      });
-    });
-
-    req.setTimeout(timeoutMs, () => {
-      req.destroy(new Error('Request timed out'));
-    });
-    req.on('error', reject);
-  });
-}
-
-async function findCompatibleServer(preferredPort, expectedVersion, expectedPackageName) {
-  const port = normalizePort(preferredPort);
-  try {
-    const info = await fetchJson(`${getDashboardUrl(port)}/api/app-info`);
-    if (isCompatibleServerInfo(info, expectedVersion, expectedPackageName)) {
-      return { port, dashboardUrl: info.dashboardUrl || getDashboardUrl(port), info };
-    }
-  } catch (_) {}
-  return null;
-}
-
-module.exports = {
-  fetchJson,
-  findCompatibleServer,
-  getDashboardUrl,
-  isCompatibleServerInfo,
-  normalizePort,
-};

package/electron/trayBadge.cjs

@@ -1,27 +0,0 @@
-// electron/trayBadge.cjs
-
-/**
- * Format token count as compact string for tray badge.
- * Examples: 1234 -> "1.2K", 567890 -> "567.9K", 1500000 -> "1.5M"
- */
-function formatTokens(tokens) {
-  tokens = Number(tokens) || 0;
-
-  if (tokens >= 1e6) return (tokens / 1e6).toFixed(1) + 'M';
-  if (tokens >= 1e3) return (tokens / 1e3).toFixed(1) + 'K';
-  if (tokens > 0) return String(tokens);
-  return '0';
-}
-
-/**
- * Format cost as compact string for tray badge (max 5 chars).
- * Examples: 1.234 -> "$1.2", 12.5 -> "$12", 0.05 -> "$0.1", 123.4 -> "$123"
- */
-function formatCost(cost) {
-  if (cost < 0.05) return '$0';
-  if (cost < 10) return '$' + cost.toFixed(1);
-  if (cost < 100) return '$' + Math.round(cost);
-  return '$' + Math.round(cost);
-}
-
-module.exports = { formatCost, formatTokens };