@mdrv/opencode-quota 262.0.0

package/bin/glm-quota.ts

@@ -0,0 +1,467 @@
+#!/usr/bin/env -S bun
+
+/**
+ * GLM quota CLI tool
+ * Fetches and displays Z.AI GLM Coding Plan usage statistics from command line
+ * Credentials are fetched from OpenCode's auth.json
+ */
+
+import * as https from 'https'
+import * as os from 'os'
+import * as path from 'path'
+import { configureLogging, getLogger } from '../src/shared/logging.js'
+
+const COMMAND_NAME = 'opencode-glm-quota'
+const AUTH_JSON_PATH = path.join(os.homedir(), '.local', 'share', 'opencode', 'auth.json')
+
+/**
+ * Type definitions
+ */
+type Platform = 'ZAI' | 'ZHIPU'
+type Provider = 'zai' | 'zai-coding-plan' | 'zhipu'
+
+interface Credentials {
+	token: string
+	platform: Platform
+}
+
+type AuthJson = Record<string, { key?: string; token?: string }>
+
+// API Response wrapper
+interface ApiResponse<T = unknown> {
+	code: number
+	msg: string
+	data: T
+	success: boolean
+}
+
+// Quota limit types
+interface UsageDetail {
+	modelCode: string
+	usage: number
+}
+
+interface QuotaLimit {
+	type: 'TIME_LIMIT' | 'TOKENS_LIMIT'
+	unit: number
+	number: number
+	usage?: number
+	currentValue?: number
+	remaining?: number
+	percentage: number
+	nextResetTime: number
+	usageDetails?: UsageDetail[]
+}
+
+interface QuotaData {
+	limits: QuotaLimit[]
+	level: string
+}
+
+interface ZaiQuotaResponse extends ApiResponse<QuotaData> {}
+
+// Global logger, assigned after configureLogging()
+let logger: ReturnType<typeof getLogger>
+
+/**
+ * Format Unix timestamp to readable date
+ */
+function formatTimestamp(timestamp: number): string {
+	const date = new Date(timestamp)
+	return date.toLocaleString('en-US', {
+		month: 'short',
+		day: 'numeric',
+		hour: '2-digit',
+		minute: '2-digit',
+		hour12: true,
+	})
+}
+
+/**
+ * Calculate duration from now to a timestamp
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Human-readable duration (e.g., "7d 4h 32m 15s", "2h 57m 31s", "5m")
+ */
+function calculateDuration(timestamp: number): string {
+	const now = new Date().getTime()
+	const diffMs = timestamp - now
+
+	// If timestamp is in the past, show "0d 0h 0m 0s"
+	if (diffMs <= 0) {
+		return '0d 0h 0m 0s'
+	}
+
+	const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24))
+	const diffHours = Math.floor((diffMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60))
+	const diffMinutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60))
+	const diffSeconds = Math.floor((diffMs % (1000 * 60)) / 1000)
+
+	// Build duration string, hiding zero values
+	const parts: string[] = []
+	if (diffDays > 0) parts.push(`${diffDays}d`)
+	if (diffHours > 0) parts.push(`${diffHours}h`)
+	if (diffMinutes > 0) parts.push(`${diffMinutes}m`)
+	if (diffSeconds > 0) parts.push(`${diffSeconds}s`)
+
+	return parts.length > 0 ? parts.join(' ') : '0s'
+}
+
+/**
+ * Parse and format quota limit data
+ */
+function parseQuotaLimit(response: string): { parsed: ZaiQuotaResponse; formatted: string } {
+	logger.debug('Parsing quota limit response')
+	const parsed = JSON.parse(response) as ZaiQuotaResponse
+	logger.debug(`API response code: ${parsed.code}, msg: ${parsed.msg}`)
+
+	if (!parsed.success || parsed.code !== 200) {
+		throw new Error(`API error: ${parsed.msg}`)
+	}
+
+	const { limits, level } = parsed.data
+	logger.debug(`Plan level: ${level}, limits: ${limits.length}`)
+
+	let output = `Plan Level: ${level}\n`
+
+	for (const limit of limits) {
+		logger.debug(`Processing limit type: ${limit.type}`)
+		const timeWindow = limit.type === 'TIME_LIMIT' ? '1-month window' : '5-hour rolling'
+		output += `\n${limit.type} (${timeWindow}):\n`
+		output += `  Used: ${limit.percentage}%\n`
+
+		if (limit.type === 'TIME_LIMIT' && limit.usageDetails) {
+			output += `  Tool Usage:\n`
+			for (const detail of limit.usageDetails) {
+				logger.debug(`Tool ${detail.modelCode}: ${detail.usage}`)
+				output += `    ${detail.modelCode}: ${detail.usage}\n`
+			}
+		}
+
+		if (limit.type === 'TOKENS_LIMIT' && limit.usage !== undefined && limit.remaining !== undefined) {
+			output += `  Tokens: ${limit.usage} / ${limit.usage + limit.remaining}\n`
+		}
+
+		const resetTime = formatTimestamp(limit.nextResetTime)
+		const duration = calculateDuration(limit.nextResetTime)
+		logger.debug(`Next reset: ${resetTime} (${duration})`)
+		output += `  Next Reset: ${resetTime} (${duration})\n`
+	}
+
+	logger.info('Quota limit data parsed successfully')
+	return { parsed, formatted: output }
+}
+
+/**
+ * Parse generic API response
+ */
+function parseResponse<T>(response: string, endpointName: string): T {
+	logger.debug(`Parsing ${endpointName} response`)
+	const parsed = JSON.parse(response) as ApiResponse<T>
+
+	if (!parsed.success || parsed.code !== 200) {
+		throw new Error(`API error from ${endpointName}: ${parsed.msg}`)
+	}
+
+	logger.debug(`${endpointName} parsed successfully`)
+	return parsed.data
+}
+
+/**
+ * Make HTTPS request with timeout
+ */
+function makeRequest(
+	url: string,
+	token: string,
+): Promise<string> {
+	logger.debug(`Making request to ${url}`)
+	logger.debug(`Using token: ${token.slice(0, 8)}...${token.slice(-4)}`)
+
+	return new Promise((resolve, reject) => {
+		const timeout = 10000 // 10 seconds
+		const timer = setTimeout(() => {
+			req.destroy()
+			logger.error(`Request timeout for ${url}`)
+			reject(new Error('Request timeout'))
+		}, timeout)
+
+		const urlObj = new URL(url)
+		const options = {
+			hostname: urlObj.hostname,
+			port: urlObj.port || 443,
+			path: urlObj.pathname + urlObj.search,
+			method: 'GET',
+			headers: {
+				'Authorization': token,
+				'Accept-Language': 'en-US,en',
+				'Content-Type': 'application/json',
+			},
+		}
+
+		logger.debug(`Request options: ${
+			JSON.stringify({
+				hostname: options.hostname,
+				path: options.path,
+				method: options.method,
+			})
+		}`)
+
+		const req = https.request(options, (res) => {
+			let data = ''
+
+			logger.debug(`Response status: ${res.statusCode} ${res.statusMessage}`)
+
+			res.on('data', chunk => {
+				data += chunk
+			})
+
+			res.on('end', () => {
+				clearTimeout(timer)
+				if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+					logger.debug(`Response received: ${data.slice(0, 100)}... (${data.length} bytes)`)
+					resolve(data)
+				} else {
+					logger.error(`HTTP error: ${res.statusCode} ${res.statusMessage}`)
+					logger.debug(`Error response: ${data}`)
+					reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`))
+				}
+			})
+		})
+
+		req.on('error', (err) => {
+			clearTimeout(timer)
+			logger.error(`Request error: ${err.message}`)
+			reject(err)
+		})
+
+		req.end()
+	})
+}
+
+/**
+ * Get credentials from OpenCode auth.json
+ */
+function getCredentials(): Credentials | null {
+	logger.debug(`Looking for credentials at ${AUTH_JSON_PATH}`)
+
+	try {
+		const fs = require('fs')
+		if (!fs.existsSync(AUTH_JSON_PATH)) {
+			logger.debug('auth.json does not exist')
+			return null
+		}
+
+		const content = fs.readFileSync(AUTH_JSON_PATH, 'utf-8')
+		const auth = JSON.parse(content) as AuthJson
+
+		logger.debug(`auth.json loaded with ${Object.keys(auth).length} providers`)
+
+		const providers: Record<string, Provider> = {
+			'zai-coding-plan': 'zai',
+			'zai': 'zai',
+			'zhipu': 'zhipu',
+		}
+
+		for (const [providerId, platform] of Object.entries(providers)) {
+			const provider = auth[providerId]
+			const token = provider?.key ?? provider?.token
+			if (token) {
+				const credentials: Credentials = {
+					token,
+					platform: platform === 'zhipu' ? 'ZHIPU' : 'ZAI',
+				}
+				logger.info(`Found credentials for provider: ${providerId}`)
+				logger.debug(`Platform: ${credentials.platform}`)
+				return credentials
+			}
+		}
+
+		logger.debug('No credentials found for any provider')
+		return null
+	} catch (error) {
+		logger.error(`Error reading auth.json: ${error}`)
+		return null
+	}
+}
+
+/**
+ * Display help message
+ */
+function showHelp() {
+	console.log(`
+${COMMAND_NAME} - Check Z.AI GLM Coding Plan quota from terminal
+
+USAGE:
+  bun run bin/glm-quota.ts [--raw|--pretty] [--debug]
+
+OPTIONS:
+  --raw        Output raw JSON (default: pretty output)
+  --pretty      Explicit pretty output (same as default)
+  --debug, -d   Enable debug logging (logs hidden by default)
+  --help, -h    Display this help message
+
+AUTHENTICATION:
+  Reads credentials from ~/.local/share/opencode/auth.json
+  Provider: zai-coding-plan, zai, or zhipu
+
+EXAMPLES:
+  bun run bin/glm-quota.ts
+  bun run bin/glm-quota.ts --debug
+  bun run bin/glm-quota.ts --raw
+`)
+}
+
+/**
+ * Main CLI entry point
+ */
+async function main() {
+	const args = process.argv.slice(2)
+
+	// Check for help flag first (before logging config)
+	if (args.includes('--help') || args.includes('-h')) {
+		showHelp()
+		process.exit(0)
+	}
+
+	// Check for debug flag before configuring logging
+	const debugMode = args.includes('--debug') || args.includes('-d')
+
+	// Only configure logging when --debug is present
+	if (debugMode) {
+		await configureLogging('debug')
+	}
+
+	// Create logger after configureLogging (or with no-op if not configured)
+	if (debugMode) {
+		logger = getLogger(['opencode-quota', 'cli', 'glm'])
+	} else {
+		// No-op logger when debug mode is off
+		logger = {
+			debug: () => {},
+			info: () => {},
+			warn: () => {},
+			error: () => {},
+		} as unknown as ReturnType<typeof getLogger>
+	}
+
+	logger.info(`${COMMAND_NAME} starting...`)
+
+	const rawOutput = args.includes('--raw')
+	// --pretty is accepted but same as default (explicitly allow it for completeness)
+
+	logger.debug(`Arguments: ${args.join(' ')}`)
+	logger.debug(`Raw output: ${rawOutput}`)
+
+	try {
+		// Get credentials from OpenCode auth.json
+		const credentials = getCredentials()
+
+		if (!credentials) {
+			logger.error('No credentials found')
+			console.error(`\n${COMMAND_NAME}: Not configured.\nPlease connect to Z.AI in OpenCode first.\n`)
+			process.exit(1)
+		}
+
+		// Query API
+		const endpoints = {
+			ZAI: {
+				modelUsage: 'https://api.z.ai/api/monitor/usage/model-usage',
+				toolUsage: 'https://api.z.ai/api/monitor/usage/tool-usage',
+				quotaLimit: 'https://api.z.ai/api/monitor/usage/quota/limit',
+			},
+			ZHIPU: {
+				modelUsage: 'https://open.bigmodel.cn/api/monitor/usage/model-usage',
+				toolUsage: 'https://open.bigmodel.cn/api/monitor/usage/tool-usage',
+				quotaLimit: 'https://open.bigmodel.cn/api/monitor/usage/quota/limit',
+			},
+		}
+
+		const urls = endpoints[credentials.platform]
+
+		logger.info(`Querying ${credentials.platform} endpoints...`)
+
+		// Make requests
+		const responses = await Promise.all([
+			makeRequest(urls.quotaLimit, credentials.token),
+			makeRequest(urls.modelUsage, credentials.token),
+			makeRequest(urls.toolUsage, credentials.token),
+		])
+
+		logger.info(`Received ${responses.length} responses`)
+
+		if (!rawOutput) {
+			// Parse and display formatted output
+			const [quotaLimitRaw, modelUsageRaw, toolUsageRaw] = responses
+
+			if (quotaLimitRaw.length === 0) {
+				logger.error('Quota limit endpoint returned empty response')
+				console.error(`\n${COMMAND_NAME}: No quota data received.\n`)
+				process.exit(1)
+			}
+
+			// Parse and display quota limit
+			try {
+				const { formatted } = parseQuotaLimit(quotaLimitRaw)
+				console.log(formatted)
+			} catch (error) {
+				logger.error(`Failed to parse quota limit: ${error}`)
+				throw error
+			}
+
+			// Parse model usage if available
+			if (modelUsageRaw.length > 0) {
+				try {
+					const modelUsage = parseResponse<unknown>(modelUsageRaw, 'model-usage')
+					logger.info('Model usage data received')
+					console.log('\nModel Usage:')
+					console.log(JSON.stringify(modelUsage, null, 2))
+				} catch (error) {
+					logger.warn(`Failed to parse model usage: ${error}`)
+				}
+			}
+
+			// Parse tool usage if available
+			if (toolUsageRaw.length > 0) {
+				try {
+					const toolUsage = parseResponse<unknown>(toolUsageRaw, 'tool-usage')
+					logger.info('Tool usage data received')
+					console.log('\nTool Usage:')
+					console.log(JSON.stringify(toolUsage, null, 2))
+				} catch (error) {
+					logger.warn(`Failed to parse tool usage: ${error}`)
+				}
+			}
+		} else {
+			// Print raw responses (one per line), skip empty ones
+			const endpointNames = ['quota/limit', 'model-usage', 'tool-usage']
+			let hasOutput = false
+
+			responses.forEach((response, index) => {
+				if (response.length > 0) {
+					console.log(response)
+					hasOutput = true
+				} else {
+					logger.warn(`Endpoint ${endpointNames[index]} returned empty response (0 bytes)`)
+				}
+			})
+
+			if (!hasOutput) {
+				console.error(`\n${COMMAND_NAME}: No data received from any endpoint.\n`)
+				process.exit(1)
+			}
+		}
+
+		logger.info('Completed successfully')
+	} catch (error) {
+		if (error instanceof Error) {
+			logger.error(`${error.name}: ${error.message}`)
+			console.error(`\n${COMMAND_NAME}: ${error.message}\n`)
+		} else {
+			logger.error(`Unknown error: ${String(error)}`)
+			console.error(`\n${COMMAND_NAME}: Unknown error occurred\n`)
+		}
+		process.exit(1)
+	}
+}
+
+// Run CLI
+main()