glad-web 1.0.45 → 2.0.1

package/lib/session/text-history.js

@@ -1,274 +0,0 @@
-class TextHistory {
-  constructor(options = {}) {
-    this.maxBytes = options.maxBytes || 5 * 1024 * 1024;
-    this.debugLabel = options.debugLabel || 'session';
-    this.lines = [''];
-    this.row = 0;
-    this.col = 0;
-    this.updatedAt = Date.now();
-    this.truncated = false;
-    this.totalWrites = 0;
-    this.totalBytes = 0;
-    this.escapeCount = 0;
-    this.clearEvents = 0;
-    this.eraseLineEvents = 0;
-    this.cursorMoveEvents = 0;
-    this.trimEvents = 0;
-    this.lastEvents = [];
-  }
-
-  write(data) {
-    if (!data) return;
-    const text = String(data);
-    this.totalWrites += 1;
-    this.totalBytes += Buffer.byteLength(text, 'utf8');
-
-    for (let i = 0; i < text.length; i++) {
-      const ch = text[i];
-
-      if (ch === '\x1b') {
-        this.escapeCount += 1;
-        i = this.skipEscape(text, i);
-        continue;
-      }
-
-      if (ch === '\r') {
-        this.col = 0;
-        continue;
-      }
-
-      if (ch === '\n') {
-        this.newLine();
-        continue;
-      }
-
-      if (ch === '\b') {
-        this.col = Math.max(0, this.col - 1);
-        continue;
-      }
-
-      if (ch === '\t') {
-        const spaces = 4 - (this.col % 4);
-        for (let j = 0; j < spaces; j++) this.writeChar(' ');
-        continue;
-      }
-
-      if (ch >= ' ' || ch === '\u00a0') {
-        this.writeChar(ch);
-      }
-    }
-
-    this.updatedAt = Date.now();
-    this.trim();
-  }
-
-  toJSON() {
-    return {
-      text: this.toString(),
-      updatedAt: this.updatedAt,
-      truncated: this.truncated,
-      bytes: Buffer.byteLength(this.toString(), 'utf8'),
-      lines: this.lines.length
-    };
-  }
-
-  getDebugSnapshot(options = {}) {
-    const tailLines = options.tailLines || 12;
-    return {
-      label: this.debugLabel,
-      updatedAt: this.updatedAt,
-      truncated: this.truncated,
-      row: this.row,
-      col: this.col,
-      lines: this.lines.length,
-      bytes: Buffer.byteLength(this.lines.join('\n'), 'utf8'),
-      totalWrites: this.totalWrites,
-      totalBytes: this.totalBytes,
-      escapeCount: this.escapeCount,
-      clearEvents: this.clearEvents,
-      eraseLineEvents: this.eraseLineEvents,
-      cursorMoveEvents: this.cursorMoveEvents,
-      trimEvents: this.trimEvents,
-      lastEvents: [...this.lastEvents],
-      tailPreview: this.previewText(this.lines.slice(-tailLines).join('\n'))
-    };
-  }
-
-  toString() {
-    return this.lines.join('\n').replace(/\s+$/g, '');
-  }
-
-  writeChar(ch) {
-    this.ensureRow();
-    const line = this.lines[this.row] || '';
-    const padded = line.length < this.col ? line + ' '.repeat(this.col - line.length) : line;
-    this.lines[this.row] = padded.slice(0, this.col) + ch + padded.slice(this.col + 1);
-    this.col += 1;
-  }
-
-  newLine() {
-    this.row += 1;
-    this.col = 0;
-    this.ensureRow();
-  }
-
-  ensureRow() {
-    while (this.row >= this.lines.length) {
-      this.lines.push('');
-    }
-  }
-
-  skipEscape(text, index) {
-    const next = text[index + 1];
-
-    if (next === ']') {
-      return this.skipOsc(text, index + 2);
-    }
-
-    if (next === '[') {
-      return this.handleCsi(text, index + 2);
-    }
-
-    return Math.min(index + 1, text.length - 1);
-  }
-
-  skipOsc(text, index) {
-    for (let i = index; i < text.length; i++) {
-      if (text[i] === '\x07') return i;
-      if (text[i] === '\x1b' && text[i + 1] === '\\') return i + 1;
-    }
-    return text.length - 1;
-  }
-
-  handleCsi(text, index) {
-    let i = index;
-    while (i < text.length && !/[A-Za-z@`~]/.test(text[i])) {
-      i++;
-    }
-    if (i >= text.length) return text.length - 1;
-
-    const params = text.slice(index, i);
-    const command = text[i];
-    this.applyCsi(params, command);
-    return i;
-  }
-
-  applyCsi(params, command) {
-    const values = params
-      .replace(/[?>!]/g, '')
-      .split(';')
-      .filter(Boolean)
-      .map(value => Number.parseInt(value, 10))
-      .map(value => Number.isFinite(value) ? value : 0);
-    const first = values[0] || 0;
-
-    if (command === 'K') {
-      this.eraseLineEvents += 1;
-      this.recordEvent(`CSI K(${first})`);
-      this.eraseLine(first);
-      return;
-    }
-
-    if (command === 'J') {
-      if (first === 2 || first === 3) {
-        this.clearEvents += 1;
-        this.recordEvent(`CSI J(${first}) ignored-clear`);
-        this.startFreshLineAfterClear();
-      }
-      return;
-    }
-
-    if (command === 'H' || command === 'f') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI ${command}(${params || ''}) ignored-cursor`);
-      return;
-    }
-
-    if (command === 'A') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI A(${first || 1}) ignored-cursor`);
-      return;
-    }
-
-    if (command === 'B') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI B(${first || 1}) ignored-cursor`);
-      return;
-    }
-
-    if (command === 'C') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI C(${first || 1}) ignored-cursor`);
-      return;
-    }
-
-    if (command === 'D') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI D(${first || 1}) ignored-cursor`);
-      return;
-    }
-
-    if (command === 'G') {
-      this.cursorMoveEvents += 1;
-      this.recordEvent(`CSI G(${first || 1}) ignored-cursor`);
-    }
-  }
-
-  eraseLine(mode) {
-    this.ensureRow();
-    const line = this.lines[this.row] || '';
-    if (mode === 1) {
-      this.lines[this.row] = ' '.repeat(Math.min(this.col, line.length)) + line.slice(this.col);
-    } else if (mode === 2) {
-      this.lines[this.row] = '';
-      this.col = 0;
-    } else {
-      this.lines[this.row] = line.slice(0, this.col);
-    }
-  }
-
-  startFreshLineAfterClear() {
-    const hasContent = this.lines.some(line => line.length > 0);
-    const currentLine = this.lines[this.row] || '';
-    if (hasContent && currentLine.length > 0) this.newLine();
-    this.row = this.lines.length - 1;
-    this.col = 0;
-    this.lines[this.row] = '';
-  }
-
-  trim() {
-    let bytes = Buffer.byteLength(this.lines.join('\n'), 'utf8');
-    while (bytes > this.maxBytes && this.lines.length > 1) {
-      const removed = this.lines.shift();
-      bytes -= Buffer.byteLength(removed, 'utf8') + 1;
-      this.row = Math.max(0, this.row - 1);
-      this.truncated = true;
-      this.trimEvents += 1;
-    }
-
-    if (bytes > this.maxBytes && this.lines.length === 1) {
-      const keepChars = Math.floor(this.maxBytes / 2);
-      this.lines[0] = this.lines[0].slice(-keepChars);
-      this.col = Math.min(this.col, this.lines[0].length);
-      this.truncated = true;
-      this.trimEvents += 1;
-    }
-  }
-
-  recordEvent(message) {
-    this.lastEvents.push(`${new Date().toISOString()} ${message}`);
-    if (this.lastEvents.length > 25) this.lastEvents.shift();
-  }
-
-  previewText(text, maxChars = 400) {
-    if (!text) return '';
-    const normalized = String(text)
-      .replace(/\r/g, '\\r')
-      .replace(/\n/g, '\\n')
-      .replace(/\t/g, '\\t')
-      .replace(/\x1b/g, '\\x1b');
-    return normalized.length > maxChars ? normalized.slice(-maxChars) : normalized;
-  }
-}
-
-module.exports = TextHistory;

package/lib/usage/ccusage-runner.js

@@ -1,128 +0,0 @@
-const { spawn } = require('child_process');
-const { chmodSync, statSync } = require('fs');
-
-const MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
-const DEFAULT_TIMEOUT_MS = 45000;
-
-const NATIVE_PACKAGES = {
-  'darwin-arm64': '@ccusage/ccusage-darwin-arm64',
-  'darwin-x64': '@ccusage/ccusage-darwin-x64',
-  'linux-arm64': '@ccusage/ccusage-linux-arm64',
-  'linux-x64': '@ccusage/ccusage-linux-x64',
-  'win32-arm64': '@ccusage/ccusage-win32-arm64',
-  'win32-x64': '@ccusage/ccusage-win32-x64'
-};
-
-function resolveCcusageBinary(platform = process.platform, arch = process.arch) {
-  const packageName = NATIVE_PACKAGES[`${platform}-${arch}`];
-  if (!packageName) {
-    throw new Error(`ccusage is not available for ${platform}-${arch}`);
-  }
-  const binaryName = platform === 'win32' ? 'ccusage.exe' : 'ccusage';
-  try {
-    return require.resolve(`${packageName}/bin/${binaryName}`);
-  } catch (_error) {
-    throw new Error(`ccusage native package is missing for ${platform}-${arch}`);
-  }
-}
-
-function ensureCcusageBinaryExecutable(binaryPath, options = {}) {
-  const platform = options.platform || process.platform;
-  if (platform === 'win32') return binaryPath;
-
-  const statPath = options.statPath || statSync;
-  const chmodPath = options.chmodPath || chmodSync;
-  try {
-    // ccusage's platform packages can be installed without execute bits. Its JS
-    // wrapper repairs them too, but this runner intentionally spawns the native binary.
-    if ((statPath(binaryPath).mode & 0o111) === 0) chmodPath(binaryPath, 0o755);
-    return binaryPath;
-  } catch (error) {
-    throw new Error(`ccusage native binary is not executable: ${error.message}`);
-  }
-}
-
-function reportArgs(timezone) {
-  return [
-    'daily',
-    '--sections', 'daily,weekly,monthly',
-    '--by-agent',
-    '--json',
-    '--offline',
-    '--timezone', timezone
-  ];
-}
-
-class CcusageRunner {
-  constructor(options = {}) {
-    this.binaryPath = options.binaryPath
-      || ensureCcusageBinaryExecutable(resolveCcusageBinary());
-    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
-    this.spawnProcess = options.spawnProcess || spawn;
-  }
-
-  loadAllPeriods(timezone) {
-    return this.runJson(reportArgs(timezone));
-  }
-
-  runJson(args) {
-    return new Promise((resolve, reject) => {
-      const child = this.spawnProcess(this.binaryPath, args, {
-        env: { ...process.env, NO_COLOR: '1' },
-        shell: false,
-        windowsHide: true
-      });
-      const stdout = [];
-      const stderr = [];
-      let outputBytes = 0;
-      let stderrBytes = 0;
-      let settled = false;
-
-      const finish = callback => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        callback();
-      };
-      const timer = setTimeout(() => {
-        child.kill();
-        finish(() => reject(new Error('ccusage timed out while reading local usage data')));
-      }, this.timeoutMs);
-
-      child.stdout.on('data', chunk => {
-        outputBytes += chunk.length;
-        if (outputBytes > MAX_OUTPUT_BYTES) {
-          child.kill();
-          finish(() => reject(new Error('ccusage report exceeded the safe output limit')));
-          return;
-        }
-        stdout.push(chunk);
-      });
-      child.stderr.on('data', chunk => {
-        if (stderrBytes >= 64 * 1024) return;
-        stderr.push(chunk);
-        stderrBytes += chunk.length;
-      });
-      child.on('error', error => finish(() => reject(new Error(`Unable to start ccusage: ${error.message}`))));
-      child.on('close', code => finish(() => {
-        const errorText = Buffer.concat(stderr).toString('utf8').trim();
-        if (code !== 0) {
-          reject(new Error(errorText || `ccusage exited with code ${code}`));
-          return;
-        }
-        try {
-          resolve(JSON.parse(Buffer.concat(stdout).toString('utf8')));
-        } catch (_error) {
-          reject(new Error('ccusage returned invalid JSON'));
-        }
-      }));
-    });
-  }
-}
-
-module.exports = {
-  CcusageRunner,
-  ensureCcusageBinaryExecutable,
-  reportArgs,
-  resolveCcusageBinary
-};

package/lib/usage/source-catalog.js

@@ -1,26 +0,0 @@
-const SOURCES = [
-  { id: 'codex', label: 'Codex', badge: 'CX' },
-  { id: 'claude', label: 'Claude', badge: 'CL' },
-  { id: 'gemini', label: 'Gemini', badge: 'GE' },
-  { id: 'opencode', label: 'OpenCode', badge: 'OC' },
-  { id: 'copilot', label: 'Copilot', badge: 'CP' },
-  { id: 'amp', label: 'Amp', badge: 'AM' },
-  { id: 'droid', label: 'Droid', badge: 'DR' },
-  { id: 'codebuff', label: 'Codebuff', badge: 'CB' },
-  { id: 'hermes', label: 'Hermes', badge: 'HE' },
-  { id: 'pi', label: 'Pi', badge: 'PI' },
-  { id: 'goose', label: 'Goose', badge: 'GO' },
-  { id: 'kilo', label: 'Kilo', badge: 'KI' },
-  { id: 'kimi', label: 'Kimi', badge: 'KM' },
-  { id: 'qwen', label: 'Qwen', badge: 'QW' },
-  { id: 'openclaw', label: 'OpenClaw', badge: 'OA' },
-  { id: 'grok', label: 'Grok', badge: 'GR' }
-];
-
-const SOURCE_BY_ID = new Map(SOURCES.map(source => [source.id, source]));
-
-function getUsageSource(id) {
-  return SOURCE_BY_ID.get(String(id || '').toLowerCase()) || null;
-}
-
-module.exports = { SOURCES, getUsageSource };

package/lib/usage/usage-service.js

@@ -1,226 +0,0 @@
-const { CcusageRunner } = require('./ccusage-runner');
-const { SOURCES, getUsageSource } = require('./source-catalog');
-
-const SCOPES = new Set(['weekly', 'monthly']);
-const CACHE_TTL_MS = 5 * 60 * 1000;
-
-function defaultTimezone() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-  } catch (_error) {
-    return 'UTC';
-  }
-}
-
-function ccusageVersion() {
-  try {
-    return require('ccusage/package.json').version;
-  } catch (_error) {
-    return 'unknown';
-  }
-}
-
-function positiveNumber(value) {
-  const number = Number(value);
-  return Number.isFinite(number) && number > 0 ? number : 0;
-}
-
-function isGptModel(modelName) {
-  return /^gpt(?:-|$)/i.test(String(modelName || ''));
-}
-
-function modelCost(sourceId, modelName, cost) {
-  if (sourceId !== 'codex' || !isGptModel(modelName)) return null;
-  const value = positiveNumber(cost);
-  return value > 0 ? value : null;
-}
-
-function normalizeModel(sourceId, breakdown) {
-  const uncachedInputTokens = positiveNumber(breakdown.inputTokens)
-    + positiveNumber(breakdown.cacheCreationTokens);
-  const cachedInputTokens = positiveNumber(breakdown.cacheReadTokens);
-  const outputTokens = positiveNumber(breakdown.outputTokens);
-  return {
-    modelName: String(breakdown.modelName || 'Unknown'),
-    uncachedInputTokens,
-    cachedInputTokens,
-    outputTokens,
-    totalTokens: uncachedInputTokens + cachedInputTokens + outputTokens,
-    estimatedCostUSD: modelCost(sourceId, breakdown.modelName, breakdown.cost)
-  };
-}
-
-function sumModels(models) {
-  return models.reduce((totals, model) => {
-    totals.uncachedInputTokens += model.uncachedInputTokens;
-    totals.cachedInputTokens += model.cachedInputTokens;
-    totals.outputTokens += model.outputTokens;
-    totals.totalTokens += model.totalTokens;
-    if (model.estimatedCostUSD !== null) {
-      totals.estimatedCostUSD = (totals.estimatedCostUSD || 0) + model.estimatedCostUSD;
-    }
-    return totals;
-  }, {
-    uncachedInputTokens: 0,
-    cachedInputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    estimatedCostUSD: null
-  });
-}
-
-function fallbackModel(sourceId, agentRow) {
-  const names = Array.isArray(agentRow.modelsUsed) ? agentRow.modelsUsed : [];
-  const modelName = names.length === 1 ? names[0] : names.length > 1 ? 'Multiple models' : 'Unknown';
-  return normalizeModel(sourceId, {
-    modelName,
-    inputTokens: agentRow.inputTokens,
-    cacheCreationTokens: agentRow.cacheCreationTokens,
-    cacheReadTokens: agentRow.cacheReadTokens,
-    outputTokens: agentRow.outputTokens,
-    cost: names.length === 1 ? agentRow.totalCost : null
-  });
-}
-
-function normalizeAgentRow(sourceId, period, agentRow) {
-  const breakdowns = Array.isArray(agentRow.modelBreakdowns) ? agentRow.modelBreakdowns : [];
-  const models = breakdowns.length
-    ? breakdowns.map(item => normalizeModel(sourceId, item))
-    : [fallbackModel(sourceId, agentRow)];
-  models.sort((a, b) => b.totalTokens - a.totalTokens || a.modelName.localeCompare(b.modelName));
-  return { period, models, totals: sumModels(models) };
-}
-
-function findAgentRow(row, sourceId) {
-  return Array.isArray(row && row.agents)
-    ? row.agents.find(agent => agent && agent.agent === sourceId) || null
-    : null;
-}
-
-function availablePeriods(raw, scope, sourceId) {
-  return (raw[scope] || [])
-    .filter(row => findAgentRow(row, sourceId))
-    .map(row => String(row.period || ''))
-    .filter(Boolean)
-    .sort()
-    .reverse();
-}
-
-function dateInsideScope(date, scope, selectedPeriod) {
-  if (scope === 'monthly') return date.startsWith(`${selectedPeriod}-`);
-  const start = new Date(`${selectedPeriod}T00:00:00Z`);
-  const candidate = new Date(`${date}T00:00:00Z`);
-  if (Number.isNaN(start.getTime()) || Number.isNaN(candidate.getTime())) return false;
-  const end = new Date(start);
-  end.setUTCDate(end.getUTCDate() + 7);
-  return candidate >= start && candidate < end;
-}
-
-function buildDashboard(raw, sourceId, scope, requestedPeriod) {
-  const periods = availablePeriods(raw, scope, sourceId);
-  const selectedPeriod = periods.includes(requestedPeriod) ? requestedPeriod : periods[0] || null;
-  if (!selectedPeriod) {
-    return { availablePeriods: [], selectedPeriod: null, summary: { models: [], totals: sumModels([]) }, days: [] };
-  }
-
-  const scopeRow = (raw[scope] || []).find(row => row.period === selectedPeriod);
-  const summaryAgent = findAgentRow(scopeRow, sourceId);
-  const summary = summaryAgent
-    ? normalizeAgentRow(sourceId, selectedPeriod, summaryAgent)
-    : { models: [], totals: sumModels([]) };
-  const days = (raw.daily || [])
-    .filter(row => dateInsideScope(String(row.period || ''), scope, selectedPeriod))
-    .flatMap(row => {
-      const agent = findAgentRow(row, sourceId);
-      return agent ? [normalizeAgentRow(sourceId, String(row.period), agent)] : [];
-    });
-  return { availablePeriods: periods, selectedPeriod, summary, days };
-}
-
-class UsageService {
-  constructor(options = {}) {
-    this.runner = options.runner || null;
-    this.timezone = options.timezone || defaultTimezone();
-    this.cacheTtlMs = options.cacheTtlMs ?? CACHE_TTL_MS;
-    this.logger = options.logger || { debug() {} };
-    this.cached = null;
-    this.loading = null;
-  }
-
-  async getSnapshot(refresh = false) {
-    const fresh = this.cached && Date.now() - this.cached.loadedAt < this.cacheTtlMs;
-    if (!refresh && fresh) return this.cached;
-    if (!refresh && this.cached) {
-      this.loadSnapshot().catch(error => this.logger.debug(`Background usage refresh failed: ${error.message}`));
-      return this.cached;
-    }
-    return this.loadSnapshot();
-  }
-
-  async loadSnapshot() {
-    if (this.loading) return this.loading;
-    if (!this.runner) this.runner = new CcusageRunner();
-    this.loading = this.runner.loadAllPeriods(this.timezone)
-      .then(raw => {
-        this.cached = { raw, loadedAt: Date.now(), generatedAt: new Date().toISOString() };
-        return this.cached;
-      })
-      .finally(() => { this.loading = null; });
-    return this.loading;
-  }
-
-  async listSources(refresh = false) {
-    const snapshot = await this.getSnapshot(refresh);
-    const present = new Set();
-    for (const scope of ['daily', 'weekly', 'monthly']) {
-      for (const row of snapshot.raw[scope] || []) {
-        for (const agent of row.agents || []) present.add(agent.agent);
-      }
-    }
-    return {
-      sources: SOURCES.filter(source => present.has(source.id)),
-      generatedAt: snapshot.generatedAt,
-      timezone: this.timezone,
-      engine: { name: 'ccusage', version: ccusageVersion(), pricingMode: 'embedded' }
-    };
-  }
-
-  async getDashboard(sourceId, scope, selectedPeriod, refresh = false) {
-    const source = getUsageSource(sourceId);
-    if (!source) {
-      const error = new Error('Unsupported usage source');
-      error.statusCode = 400;
-      throw error;
-    }
-    if (!SCOPES.has(scope)) {
-      const error = new Error('Scope must be weekly or monthly');
-      error.statusCode = 400;
-      throw error;
-    }
-    const snapshot = await this.getSnapshot(refresh);
-    return {
-      source,
-      scope,
-      ...buildDashboard(snapshot.raw, source.id, scope, selectedPeriod),
-      generatedAt: snapshot.generatedAt,
-      timezone: this.timezone,
-      engine: { name: 'ccusage', version: ccusageVersion(), pricingMode: 'embedded' },
-      cost: source.id === 'codex' ? {
-        basis: 'ccusage estimate for Codex GPT models',
-        note: 'Estimated from ccusage model pricing; it is not an actual provider bill.'
-      } : null
-    };
-  }
-}
-
-module.exports = {
-  UsageService,
-  availablePeriods,
-  buildDashboard,
-  dateInsideScope,
-  isGptModel,
-  modelCost,
-  normalizeAgentRow,
-  normalizeModel,
-  sumModels
-};