@jukanntenn/glm-plan-usage 0.0.2

package/README.md

@@ -0,0 +1,81 @@
+# @jukanntenn/glm-plan-usage
+
+GLM Plan Usage - StatusLine plugin for Claude Code
+
+## Installation
+
+```bash
+npm install -g @jukanntenn/glm-plan-usage
+```
+
+For users experiencing network issues, use npm mirror for faster installation:
+
+```bash
+npm install -g @jukanntenn/glm-plan-usage --registry https://registry.npmmirror.com
+```
+
+## Features
+
+- 📊 **Monitor**: Display GLM (ZHIPU/ZAI) coding plan usage statistics
+- 🌍 **Cross-platform**: Works on Windows, macOS, and Linux
+- 📦 **Easy installation**: One command via npm
+- 🎨 **Beautiful**: Color-coded warning levels based on usage percentage
+
+## Usage
+
+Add to your Claude Code `settings.json`:
+
+**Linux/macOS:**
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "~/.claude/glm-plan-usage/glm-plan-usage",
+    "padding": 0
+  }
+}
+```
+
+**Windows:**
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "%USERPROFILE%\\.claude\\glm-plan-usage\\glm-plan-usage.exe",
+    "padding": 0
+  }
+}
+```
+
+## Environment Variables
+
+**Note:** These variables are typically already configured in your Claude Code `settings.json`. If not, you can set them manually:
+
+**Linux/macOS:**
+
+```bash
+export ANTHROPIC_AUTH_TOKEN="your-token-here"
+export ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/anthropic"
+```
+
+**Windows (Command Prompt):**
+
+```cmd
+set ANTHROPIC_AUTH_TOKEN=your-token-here
+set ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic
+```
+
+**Windows (PowerShell):**
+
+```powershell
+$env:ANTHROPIC_AUTH_TOKEN="your-token-here"
+$env:ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/anthropic"
+```
+
+## More Information
+
+- GitHub: https://github.com/jukanntenn/glm-plan-usage
+- Issues: https://github.com/jukanntenn/glm-plan-usage/issues
+- License: MIT

package/bin/glm-plan-usage.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// 1. Priority: Use ~/.claude/glm-plan-usage/glm-plan-usage if exists
+const claudePath = path.join(
+  os.homedir(),
+  '.claude',
+  'glm-plan-usage',
+  process.platform === 'win32' ? 'glm-plan-usage.exe' : 'glm-plan-usage'
+);
+
+if (fs.existsSync(claudePath)) {
+  const result = spawnSync(claudePath, process.argv.slice(2), {
+    stdio: 'inherit',
+    shell: false
+  });
+  process.exit(result.status || 0);
+}
+
+// 2. Fallback: Use npm package binary
+const platform = process.platform;
+const arch = process.arch;
+
+// Handle special cases
+let platformKey = `${platform}-${arch}`;
+if (platform === 'linux') {
+  // Detect libc type and version
+  function getLibcInfo() {
+    try {
+      const { execSync } = require('child_process');
+      const lddOutput = execSync('ldd --version 2>/dev/null || echo ""', {
+        encoding: 'utf8',
+        timeout: 1000
+      });
+
+      // Check for musl explicitly
+      if (lddOutput.includes('musl')) {
+        return { type: 'musl' };
+      }
+
+      // Parse glibc version: "ldd (GNU libc) 2.35" format
+      const match = lddOutput.match(/(?:GNU libc|GLIBC).*?(\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1]);
+        const minor = parseInt(match[2]);
+        return { type: 'glibc', major, minor };
+      }
+
+      // If we can't detect, default to musl for safety (more portable)
+      return { type: 'musl' };
+    } catch (e) {
+      // If detection fails, default to musl (more portable)
+      return { type: 'musl' };
+    }
+  }
+
+  const libcInfo = getLibcInfo();
+
+  if (arch === 'arm64') {
+    // ARM64 Linux: choose based on libc type and version
+    if (libcInfo.type === 'musl' ||
+        (libcInfo.type === 'glibc' && (libcInfo.major < 2 || (libcInfo.major === 2 && libcInfo.minor < 35)))) {
+      platformKey = 'linux-arm64-musl';
+    } else {
+      platformKey = 'linux-arm64';
+    }
+  } else {
+    // x64 Linux: choose based on libc type and version
+    if (libcInfo.type === 'musl' ||
+        (libcInfo.type === 'glibc' && (libcInfo.major < 2 || (libcInfo.major === 2 && libcInfo.minor < 35)))) {
+      platformKey = 'linux-x64-musl';
+    }
+  }
+}
+
+const packageMap = {
+  'darwin-x64': '@jukanntenn/glm-plan-usage-darwin-x64',
+  'darwin-arm64': '@jukanntenn/glm-plan-usage-darwin-arm64',
+  'linux-x64': '@jukanntenn/glm-plan-usage-linux-x64',
+  'linux-x64-musl': '@jukanntenn/glm-plan-usage-linux-x64-musl',
+  'linux-arm64': '@jukanntenn/glm-plan-usage-linux-arm64',
+  'linux-arm64-musl': '@jukanntenn/glm-plan-usage-linux-arm64-musl',
+  'win32-x64': '@jukanntenn/glm-plan-usage-win32-x64',
+  'win32-ia32': '@jukanntenn/glm-plan-usage-win32-x64', // Use 64-bit for 32-bit systems
+};
+
+const packageName = packageMap[platformKey];
+if (!packageName) {
+  console.error(`Error: Unsupported platform ${platformKey}`);
+  console.error('Supported platforms: darwin (x64/arm64), linux (x64/arm64), win32 (x64)');
+  console.error('Please visit https://github.com/jukanntenn/glm-plan-usage for manual installation');
+  process.exit(1);
+}
+
+const binaryName = platform === 'win32' ? 'glm-plan-usage.exe' : 'glm-plan-usage';
+const binaryPath = path.join(__dirname, '..', 'node_modules', packageName, binaryName);
+
+if (!fs.existsSync(binaryPath)) {
+  console.error(`Error: Binary not found at ${binaryPath}`);
+  console.error('This might indicate a failed installation or unsupported platform.');
+  console.error('Please try reinstalling: npm install -g @jukanntenn/glm-plan-usage');
+  console.error(`Expected package: ${packageName}`);
+  process.exit(1);
+}
+
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  shell: false
+});
+
+process.exit(result.status || 0);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jukanntenn/glm-plan-usage",
+  "version": "0.0.2",
+  "description": "GLM Plan Usage - StatusLine plugin for Claude Code",
+  "bin": {
+    "glm-plan-usage": "bin/glm-plan-usage.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "optionalDependencies": {
+    "@jukanntenn/glm-plan-usage-darwin-x64": "0.0.2",
+    "@jukanntenn/glm-plan-usage-darwin-arm64": "0.0.2",
+    "@jukanntenn/glm-plan-usage-linux-x64": "0.0.2",
+    "@jukanntenn/glm-plan-usage-linux-x64-musl": "0.0.2",
+    "@jukanntenn/glm-plan-usage-linux-arm64": "0.0.2",
+    "@jukanntenn/glm-plan-usage-linux-arm64-musl": "0.0.2",
+    "@jukanntenn/glm-plan-usage-win32-x64": "0.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jukanntenn/glm-plan-usage.git"
+  },
+  "keywords": [
+    "claude",
+    "statusline",
+    "claude-code",
+    "rust",
+    "cli",
+    "glm",
+    "zhipu"
+  ],
+  "author": "Alice",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,181 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Silent mode detection
+const silent = process.env.npm_config_loglevel === 'silent' ||
+               process.env.GLM_PLAN_USAGE_SKIP_POSTINSTALL === '1';
+
+if (!silent) {
+  console.log('🚀 Setting up GLM Plan Usage for Claude Code...');
+}
+
+try {
+  const platform = process.platform;
+  const arch = process.arch;
+  const homeDir = os.homedir();
+  const claudeDir = path.join(homeDir, '.claude', 'glm-plan-usage');
+
+  // Create directory
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  // Determine platform key
+  let platformKey = `${platform}-${arch}`;
+  if (platform === 'linux') {
+    // Detect libc type and version
+    function getLibcInfo() {
+      try {
+        const { execSync } = require('child_process');
+        const lddOutput = execSync('ldd --version 2>/dev/null || echo ""', {
+          encoding: 'utf8',
+          timeout: 1000
+        });
+
+        // Check for musl explicitly
+        if (lddOutput.includes('musl')) {
+          return { type: 'musl' };
+        }
+
+        // Parse glibc version: "ldd (GNU libc) 2.35" format
+        const match = lddOutput.match(/(?:GNU libc|GLIBC).*?(\d+)\.(\d+)/);
+        if (match) {
+          const major = parseInt(match[1]);
+          const minor = parseInt(match[2]);
+          return { type: 'glibc', major, minor };
+        }
+
+        // If we can't detect, default to musl for safety (more portable)
+        return { type: 'musl' };
+      } catch (e) {
+        // If detection fails, default to musl (more portable)
+        return { type: 'musl' };
+      }
+    }
+
+    const libcInfo = getLibcInfo();
+
+    if (arch === 'arm64') {
+      // ARM64 Linux: choose based on libc type and version
+      if (libcInfo.type === 'musl' ||
+          (libcInfo.type === 'glibc' && (libcInfo.major < 2 || (libcInfo.major === 2 && libcInfo.minor < 35)))) {
+        platformKey = 'linux-arm64-musl';
+      } else {
+        platformKey = 'linux-arm64';
+      }
+    } else {
+      // x64 Linux: choose based on libc type and version
+      if (libcInfo.type === 'musl' ||
+          (libcInfo.type === 'glibc' && (libcInfo.major < 2 || (libcInfo.major === 2 && libcInfo.minor < 35)))) {
+        platformKey = 'linux-x64-musl';
+      }
+    }
+  }
+
+  const packageMap = {
+    'darwin-x64': '@jukanntenn/glm-plan-usage-darwin-x64',
+    'darwin-arm64': '@jukanntenn/glm-plan-usage-darwin-arm64',
+    'linux-x64': '@jukanntenn/glm-plan-usage-linux-x64',
+    'linux-x64-musl': '@jukanntenn/glm-plan-usage-linux-x64-musl',
+    'linux-arm64': '@jukanntenn/glm-plan-usage-linux-arm64',
+    'linux-arm64-musl': '@jukanntenn/glm-plan-usage-linux-arm64-musl',
+    'win32-x64': '@jukanntenn/glm-plan-usage-win32-x64',
+    'win32-ia32': '@jukanntenn/glm-plan-usage-win32-x64', // Use 64-bit for 32-bit
+  };
+
+  const packageName = packageMap[platformKey];
+  if (!packageName) {
+    if (!silent) {
+      console.log(`Platform ${platformKey} not supported for auto-setup`);
+    }
+    process.exit(0);
+  }
+
+  const binaryName = platform === 'win32' ? 'glm-plan-usage.exe' : 'glm-plan-usage';
+  const targetPath = path.join(claudeDir, binaryName);
+
+  // Multiple path search strategies for different package managers
+  const findBinaryPath = () => {
+    const possiblePaths = [
+      // npm/yarn: nested in node_modules
+      path.join(__dirname, '..', 'node_modules', packageName, binaryName),
+      // pnpm: try require.resolve first
+      (() => {
+        try {
+          const packagePath = require.resolve(packageName + '/package.json');
+          return path.join(path.dirname(packagePath), binaryName);
+        } catch {
+          return null;
+        }
+      })(),
+      // pnpm: flat structure fallback with version detection
+      (() => {
+        const currentPath = __dirname;
+        const pnpmMatch = currentPath.match(/(.+\.pnpm)[\\/]([^\\//]+)[\\/]/);
+        if (pnpmMatch) {
+          const pnpmRoot = pnpmMatch[1];
+          const packageNameEncoded = packageName.replace('/', '+');
+
+          try {
+            // Try to find any version of the package
+            const pnpmContents = fs.readdirSync(pnpmRoot);
+            const packagePattern = new RegExp(`^${packageNameEncoded.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}@`);
+            const matchingPackage = pnpmContents.find(dir => packagePattern.test(dir));
+
+            if (matchingPackage) {
+              return path.join(pnpmRoot, matchingPackage, 'node_modules', packageName, binaryName);
+            }
+          } catch {
+            // Fallback to current behavior if directory reading fails
+          }
+        }
+        return null;
+      })()
+    ].filter(p => p !== null);
+
+    for (const testPath of possiblePaths) {
+      if (fs.existsSync(testPath)) {
+        return testPath;
+      }
+    }
+    return null;
+  };
+
+  const sourcePath = findBinaryPath();
+  if (!sourcePath) {
+    if (!silent) {
+      console.log('Binary package not installed, skipping Claude Code setup');
+      console.log('The global glm-plan-usage command will still work via npm');
+    }
+    process.exit(0);
+  }
+
+  // Copy or link the binary
+  if (platform === 'win32') {
+    // Windows: Copy file
+    fs.copyFileSync(sourcePath, targetPath);
+  } else {
+    // Unix: Try hard link first, fallback to copy
+    try {
+      if (fs.existsSync(targetPath)) {
+        fs.unlinkSync(targetPath);
+      }
+      fs.linkSync(sourcePath, targetPath);
+    } catch {
+      fs.copyFileSync(sourcePath, targetPath);
+    }
+    fs.chmodSync(targetPath, '755');
+  }
+
+  if (!silent) {
+    console.log('✨ GLM Plan Usage is ready for Claude Code!');
+    console.log(`📍 Location: ${targetPath}`);
+    console.log('🎉 You can now use: glm-plan-usage --help');
+  }
+} catch (error) {
+  // Silent failure - don't break installation
+  if (!silent) {
+    console.log('Note: Could not auto-configure for Claude Code');
+    console.log('The global glm-plan-usage command will still work.');
+    console.log('You can manually copy glm-plan-usage to ~/.claude/glm-plan-usage/ if needed');
+  }
+}