openusage 0.1.0

package/plugins/zai/plugin.js

@@ -0,0 +1,156 @@
+(function () {
+  const BASE_URL = "https://api.z.ai"
+  const SUBSCRIPTION_URL = BASE_URL + "/api/biz/subscription/list"
+  const QUOTA_URL = BASE_URL + "/api/monitor/usage/quota/limit"
+  const PERIOD_MS = 5 * 60 * 60 * 1000
+  const MONTH_MS = 30 * 24 * 60 * 60 * 1000
+
+  function loadApiKey(ctx) {
+    const zai = ctx.host.env.get("ZAI_API_KEY")
+    if (typeof zai === "string" && zai.trim()) return zai.trim()
+
+    const glm = ctx.host.env.get("GLM_API_KEY")
+    if (typeof glm === "string" && glm.trim()) return glm.trim()
+
+    return null
+  }
+
+  function fetchSubscription(ctx, apiKey) {
+    try {
+      const resp = ctx.util.request({
+        method: "GET",
+        url: SUBSCRIPTION_URL,
+        headers: {
+          Authorization: "Bearer " + apiKey,
+          Accept: "application/json",
+        },
+        timeoutMs: 10000,
+      })
+      if (resp.status < 200 || resp.status >= 300) {
+        ctx.host.log.warn("subscription request failed: HTTP " + resp.status)
+        return null
+      }
+      const data = ctx.util.tryParseJson(resp.bodyText)
+      if (!data) return null
+      const list = data.data
+      if (!Array.isArray(list) || list.length === 0) return null
+      return {
+        productName: list[0].productName || null,
+        nextRenewTime: list[0].nextRenewTime || null,
+      }
+    } catch (e) {
+      ctx.host.log.warn("subscription request exception: " + String(e))
+      return null
+    }
+  }
+
+  function fetchQuota(ctx, apiKey) {
+    let resp
+    try {
+      resp = ctx.util.request({
+        method: "GET",
+        url: QUOTA_URL,
+        headers: {
+          Authorization: "Bearer " + apiKey,
+          Accept: "application/json",
+        },
+        timeoutMs: 10000,
+      })
+    } catch (e) {
+      ctx.host.log.error("usage request exception: " + String(e))
+      throw "Usage request failed. Check your connection."
+    }
+
+    if (ctx.util.isAuthStatus(resp.status)) {
+      throw "API key invalid. Check your Z.ai API key."
+    }
+
+    if (resp.status < 200 || resp.status >= 300) {
+      throw "Usage request failed (HTTP " + String(resp.status) + "). Try again later."
+    }
+
+    const data = ctx.util.tryParseJson(resp.bodyText)
+    if (!data) {
+      throw "Usage response invalid. Try again later."
+    }
+
+    return data
+  }
+
+  function findLimit(limits, type) {
+    for (let i = 0; i < limits.length; i++) {
+      if (limits[i].type === type || limits[i].name === type) return limits[i]
+    }
+    return null
+  }
+
+  function probe(ctx) {
+    const apiKey = loadApiKey(ctx)
+    if (!apiKey) {
+      throw "No ZAI_API_KEY found. Set up environment variable first."
+    }
+
+    const sub = fetchSubscription(ctx, apiKey)
+    const plan = sub && sub.productName ? ctx.fmt.planLabel(sub.productName) : null
+
+    const quota = fetchQuota(ctx, apiKey)
+    const lines = []
+
+    const container = quota.data || quota
+    const limits = container.limits || container
+    if (!Array.isArray(limits) || limits.length === 0) {
+      lines.push(ctx.line.badge({ label: "Session", text: "No usage data", color: "#a3a3a3" }))
+      return { plan, lines }
+    }
+
+    const tokenLimit = findLimit(limits, "TOKENS_LIMIT")
+
+    if (!tokenLimit) {
+      lines.push(ctx.line.badge({ label: "Session", text: "No usage data", color: "#a3a3a3" }))
+      return { plan, lines }
+    }
+
+    const used = typeof tokenLimit.percentage === "number" ? tokenLimit.percentage : 0
+    const resetsAt = tokenLimit.nextResetTime ? ctx.util.toIso(tokenLimit.nextResetTime) : undefined
+
+    const progressOpts = {
+      label: "Session",
+      used,
+      limit: 100,
+      format: { kind: "percent" },
+      periodDurationMs: PERIOD_MS,
+    }
+    if (resetsAt) {
+      progressOpts.resetsAt = resetsAt
+    }
+    lines.push(ctx.line.progress(progressOpts))
+
+    const timeLimit = findLimit(limits, "TIME_LIMIT")
+
+    if (timeLimit) {
+      const webUsed = typeof timeLimit.currentValue === "number" ? timeLimit.currentValue : 0
+      const webTotal = typeof timeLimit.usage === "number" ? timeLimit.usage : 0
+      const now = new Date()
+      const nextMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1))
+      const webResetsAt = timeLimit.nextResetTime
+        ? ctx.util.toIso(timeLimit.nextResetTime)
+        : nextMonth.toISOString()
+
+      const webOpts = {
+        label: "Web Searches",
+        used: webUsed,
+        limit: webTotal,
+        format: { kind: "count", suffix: "/ " + webTotal },
+        periodDurationMs: MONTH_MS,
+      }
+      if (webResetsAt) {
+        webOpts.resetsAt = webResetsAt
+      }
+      lines.push(ctx.line.progress(webOpts))
+    }
+
+    return { plan, lines }
+  }
+
+  globalThis.__openusage_plugin = { id: "zai", probe }
+})()

package/plugins/zai/plugin.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "id": "zai",
+  "name": "Z.ai",
+  "version": "0.0.1",
+  "entry": "plugin.js",
+  "icon": "icon.svg",
+  "brandColor": "#2D2D2D",
+  "cli": {
+    "category": "env",
+    "envVarNames": ["ZAI_API_KEY", "GLM_API_KEY"],
+    "envKeyLabel": "Z.ai API Key"
+  },
+  "lines": [
+    { "type": "progress", "label": "Session", "scope": "overview", "primaryOrder": 1 },
+    { "type": "progress", "label": "Web Searches", "scope": "overview" }
+  ]
+}

package/plugins/zai/plugin.test.js

@@ -0,0 +1,396 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { makeCtx } from "../test-helpers.js"
+
+const loadPlugin = async () => {
+  await import("./plugin.js")
+  return globalThis.__openusage_plugin
+}
+
+const mockEnvWithKey = (ctx, key, varName = "ZAI_API_KEY") => {
+  ctx.host.env.get.mockImplementation((name) => (name === varName ? key : null))
+}
+
+const QUOTA_RESPONSE = {
+  code: 200,
+  data: {
+    limits: [
+      {
+        type: "TOKENS_LIMIT",
+        usage: 800000000,
+        currentValue: 1900000,
+        percentage: 10,
+        nextResetTime: 1738368000000,
+        unit: 3,
+        number: 5,
+      },
+      {
+        type: "TIME_LIMIT",
+        usage: 4000,
+        currentValue: 1095,
+        percentage: 27,
+        remaining: 2905,
+        usageDetails: [
+          { modelCode: "search-prime", usage: 951 },
+          { modelCode: "web-reader", usage: 211 },
+          { modelCode: "zread", usage: 0 },
+        ],
+        unit: 5,
+        number: 1,
+      },
+    ],
+  },
+}
+
+const QUOTA_RESPONSE_NO_TIME_LIMIT = {
+  code: 200,
+  data: {
+    limits: [
+      {
+        type: "TOKENS_LIMIT",
+        usage: 800000000,
+        currentValue: 1900000,
+        percentage: 10,
+        nextResetTime: 1738368000000,
+        unit: 3,
+        number: 5,
+      },
+    ],
+  },
+}
+
+const SUBSCRIPTION_RESPONSE = {
+  data: [{ productName: "GLM Coding Max", nextRenewTime: "2026-03-12" }],
+}
+
+const mockHttp = (ctx) => {
+  ctx.host.http.request.mockImplementation((opts) => {
+    if (opts.url.includes("subscription")) {
+      return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+    }
+    return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE) }
+  })
+}
+
+describe("zai plugin", () => {
+  beforeEach(() => {
+    delete globalThis.__openusage_plugin
+    vi.resetModules()
+  })
+
+  it("throws when no env vars set", async () => {
+    const ctx = makeCtx()
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("No ZAI_API_KEY found. Set up environment variable first.")
+  })
+
+  it("uses ZAI_API_KEY when set", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("falls back to GLM_API_KEY when ZAI_API_KEY is missing", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "glm-key", "GLM_API_KEY")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("prefers ZAI_API_KEY over GLM_API_KEY", async () => {
+    const ctx = makeCtx()
+    ctx.host.env.get.mockImplementation((name) => {
+      if (name === "ZAI_API_KEY") return "zai-key"
+      if (name === "GLM_API_KEY") return "glm-key"
+      return null
+    })
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+    const authHeader = ctx.host.http.request.mock.calls[0][0].headers.Authorization
+    expect(authHeader).toBe("Bearer zai-key")
+  })
+
+  it("renders session usage as percent from quota response", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const line = result.lines.find((l) => l.label === "Session")
+    expect(line).toBeTruthy()
+    expect(line.type).toBe("progress")
+    expect(line.used).toBe(10)
+    expect(line.limit).toBe(100)
+    expect(line.format).toEqual({ kind: "percent" })
+    expect(line.periodDurationMs).toBe(5 * 60 * 60 * 1000)
+  })
+
+  it("extracts plan name from subscription response", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBe("GLM Coding Max")
+  })
+
+  it("handles subscription fetch failure gracefully", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 500, bodyText: "" }
+      }
+      return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBeNull()
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("throws on 401 from quota endpoint", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 401, bodyText: "" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("API key invalid")
+  })
+
+  it("throws on HTTP 500 from quota endpoint", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 500, bodyText: "" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("HTTP 500")
+  })
+
+  it("throws on network exception", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      throw new Error("ECONNREFUSED")
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Usage request failed. Check your connection.")
+  })
+
+  it("throws on invalid JSON from quota endpoint", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 200, bodyText: "not-json" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Usage response invalid")
+  })
+
+  it("shows badge when limits array is empty", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 200, bodyText: JSON.stringify({ data: { limits: [] } }) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines[0].text).toBe("No usage data")
+  })
+
+  it("passes resetsAt from nextResetTime (epoch ms to ISO)", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const line = result.lines.find((l) => l.label === "Session")
+    expect(line.resetsAt).toBe(new Date(1738368000000).toISOString())
+  })
+
+  it("renders Web Searches line with count format and 1st-of-month reset", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    mockHttp(ctx)
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const line = result.lines.find((l) => l.label === "Web Searches")
+    expect(line).toBeTruthy()
+    expect(line.type).toBe("progress")
+    expect(line.used).toBe(1095)
+    expect(line.limit).toBe(4000)
+    expect(line.format).toEqual({ kind: "count", suffix: "/ 4000" })
+    expect(line.periodDurationMs).toBe(30 * 24 * 60 * 60 * 1000)
+    const now = new Date()
+    const expected1st = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1))
+    expect(line.resetsAt).toBe(expected1st.toISOString())
+  })
+
+  it("skips Web Searches when TIME_LIMIT is absent", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE_NO_TIME_LIMIT) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines.find((l) => l.label === "Web Searches")).toBeUndefined()
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("Web Searches still has resetsAt (1st of month) even when subscription fails", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 500, bodyText: "" }
+      }
+      return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const line = result.lines.find((l) => l.label === "Web Searches")
+    expect(line).toBeTruthy()
+    const now = new Date()
+    const expected1st = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1))
+    expect(line.resetsAt).toBe(expected1st.toISOString())
+  })
+
+  it("handles missing nextResetTime gracefully", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    const quotaNoReset = {
+      data: {
+        limits: [
+          { type: "TOKENS_LIMIT", percentage: 10 },
+        ],
+      },
+    }
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 200, bodyText: JSON.stringify(quotaNoReset) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const line = result.lines.find((l) => l.label === "Session")
+    expect(line).toBeTruthy()
+    expect(line.resetsAt).toBeUndefined()
+  })
+
+  it("handles invalid subscription JSON without failing quota rendering", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: "not-json" }
+      }
+      return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBeNull()
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("handles subscription payload with empty list", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify({ data: [] }) }
+      }
+      return { status: 200, bodyText: JSON.stringify(QUOTA_RESPONSE) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBeNull()
+    expect(result.lines.find((l) => l.label === "Session")).toBeTruthy()
+  })
+
+  it("supports quota payloads where limits are top-level and optional fields are non-numeric", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return {
+        status: 200,
+        bodyText: JSON.stringify([
+          { type: "TOKENS_LIMIT", percentage: "10", nextResetTime: 1738368000000 },
+          { type: "TIME_LIMIT", currentValue: "1095", usage: "4000" },
+        ]),
+      }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const session = result.lines.find((l) => l.label === "Session")
+    const web = result.lines.find((l) => l.label === "Web Searches")
+    expect(session.used).toBe(0)
+    expect(web.used).toBe(0)
+    expect(web.limit).toBe(0)
+  })
+
+  it("shows no-usage badge when token limit entry is missing", async () => {
+    const ctx = makeCtx()
+    mockEnvWithKey(ctx, "test-key")
+    ctx.host.http.request.mockImplementation((opts) => {
+      if (opts.url.includes("subscription")) {
+        return { status: 200, bodyText: JSON.stringify(SUBSCRIPTION_RESPONSE) }
+      }
+      return { status: 200, bodyText: JSON.stringify({ data: { limits: [{ type: "TIME_LIMIT", usage: 10 }] } }) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.lines).toHaveLength(1)
+    expect(result.lines[0].text).toBe("No usage data")
+  })
+})