openusage 0.1.0

package/plugins/jetbrains-ai-assistant/plugin.test.js

@@ -0,0 +1,338 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { makeCtx } from "../test-helpers.js"
+
+const DARWIN_PATH = "~/Library/Application Support/JetBrains/WebStorm2025.3/options/AIAssistantQuotaManager2.xml"
+const LINUX_PATH = "~/.config/JetBrains/IntelliJIdea2025.3/options/AIAssistantQuotaManager2.xml"
+
+const loadPlugin = async () => {
+  await import("./plugin.js")
+  return globalThis.__openusage_plugin
+}
+
+function encodeXmlValue(value) {
+  return JSON.stringify(value, null, 4)
+    .replace(/&/g, "&")
+    .replace(/"/g, """)
+    .replace(/\n/g, "
")
+}
+
+function makeQuotaXml({ quotaInfo, nextRefill }) {
+  return [
+    "<application>",
+    '  <component name="AIAssistantQuotaManager2">',
+    `    <option name="nextRefill" value="${encodeXmlValue(nextRefill)}" />`,
+    `    <option name="quotaInfo" value="${encodeXmlValue(quotaInfo)}" />`,
+    "  </component>",
+    "</application>",
+  ].join("\n")
+}
+
+describe("jetbrains-ai-assistant plugin", () => {
+  beforeEach(() => {
+    delete globalThis.__openusage_plugin
+    vi.resetModules()
+  })
+
+  it("parses quota xml and emits quota + remaining lines", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "75",
+          maximum: "100",
+          available: "25",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: {
+          type: "Known",
+          next: "2099-01-01T00:00:00Z",
+          tariff: { amount: "100", duration: "PT720H" },
+        },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    const quota = result.lines.find((line) => line.label === "Quota")
+    const used = result.lines.find((line) => line.label === "Used")
+    const remaining = result.lines.find((line) => line.label === "Remaining")
+
+    expect(quota && quota.used).toBe(75)
+    expect(quota && quota.limit).toBe(100)
+    expect(quota && quota.resetsAt).toBe("2099-01-01T00:00:00.000Z")
+    expect(quota && quota.periodDurationMs).toBe(2592000000)
+    expect(used && used.value).toBe("75")
+    expect(remaining && remaining.value).toBe("25")
+  })
+
+  it("falls back to quota until when nextRefill is missing", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "50",
+          maximum: "100",
+          available: "50",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: null,
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const quota = result.lines.find((line) => line.label === "Quota")
+    expect(quota && quota.resetsAt).toBe("2099-01-31T00:00:00.000Z")
+  })
+
+  it("prefers the quota state with the latest until window", async () => {
+    const ctx = makeCtx()
+    ctx.app.platform = "macos"
+
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "10",
+          maximum: "100",
+          available: "90",
+          until: "2099-01-01T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "PT720H" } },
+      })
+    )
+
+    // Unknown platforms probe all base paths. Write second valid file in Linux path to verify latest-until selection.
+    ctx.app.platform = "unknown"
+    ctx.host.fs.writeText(
+      LINUX_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "20",
+          maximum: "100",
+          available: "80",
+          until: "2099-02-01T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-02-01T00:00:00Z", tariff: { amount: "0", duration: "PT720H" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const quota = result.lines.find((line) => line.label === "Quota")
+    expect(quota && quota.used).toBe(20)
+  })
+
+  it("computes remaining when available is missing", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "60",
+          maximum: "100",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "P30D" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const remaining = result.lines.find((line) => line.label === "Remaining")
+    expect(remaining && remaining.value).toBe("40")
+  })
+
+  it("prefers explicit tariff/topUp available over maximum-current math", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "90",
+          maximum: "100",
+          // Intentionally inconsistent to verify explicit available is preferred.
+          tariffQuota: { current: "90", maximum: "100", available: "12.5" },
+          topUpQuota: { current: "0", maximum: "0", available: "3.5" },
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "P30D" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const remaining = result.lines.find((line) => line.label === "Remaining")
+    expect(remaining && remaining.value).toBe("16")
+  })
+
+  it("breaks equal-until ties by higher used ratio", async () => {
+    const ctx = makeCtx()
+    ctx.app.platform = "unknown"
+
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "80",
+          maximum: "100",
+          available: "20",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "PT720H" } },
+      })
+    )
+    ctx.host.fs.writeText(
+      LINUX_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "30",
+          maximum: "100",
+          available: "70",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "PT720H" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const used = result.lines.find((line) => line.label === "Used")
+    expect(used && used.value).toBe("80")
+  })
+
+  it("converts JetBrains raw quota units to credits for display", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "1981684.92",
+          maximum: "2367648.941",
+          tariffQuota: { current: "1981684.92", maximum: "2367648.941", available: "385964.21" },
+          topUpQuota: { current: "0", maximum: "0", available: "0" },
+          until: "2026-04-30T21:00:00Z",
+        },
+        nextRefill: {
+          type: "Known",
+          next: "2026-03-14T06:00:54.020Z",
+          tariff: { amount: "2000000", duration: "PT720H" },
+        },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const used = result.lines.find((line) => line.label === "Used")
+    const remaining = result.lines.find((line) => line.label === "Remaining")
+
+    expect(used && used.value).toBe("19.82 / 23.68 credits")
+    expect(remaining && remaining.value).toBe("3.86 credits")
+  })
+
+  it("throws when no quota file is detected", async () => {
+    const ctx = makeCtx()
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("JetBrains AI Assistant not detected")
+  })
+
+  it("throws when quota payload is present but invalid", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: {
+          type: "Available",
+          current: "0",
+          maximum: "0",
+          until: "2099-01-31T00:00:00Z",
+        },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "0", duration: "PT720H" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("quota data unavailable")
+  })
+
+  it("discovers quota on windows", async () => {
+    const ctx = makeCtx()
+    ctx.app.platform = "windows"
+    ctx.host.fs.writeText(
+      "~/AppData/Roaming/JetBrains/WebStorm2025.3/options/AIAssistantQuotaManager2.xml",
+      makeQuotaXml({
+        quotaInfo: { current: "50", maximum: "100", available: "50", until: "2099-01-31T00:00:00Z" },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "100", duration: "PT720H" } },
+      })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const quota = result.lines.find((line) => line.label === "Quota")
+    expect(quota && quota.used).toBe(50)
+  })
+
+  it("continues gracefully when listDir throws", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(DARWIN_PATH, makeQuotaXml({
+      quotaInfo: { current: "50", maximum: "100", available: "50", until: "2099-01-31T00:00:00Z" },
+      nextRefill: null,
+    }))
+    ctx.host.fs.listDir = () => { throw new Error("permission denied") }
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("JetBrains AI Assistant not detected")
+  })
+
+  it("throws when quota file exists but quotaInfo element is absent", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      '<application><component name="AIAssistantQuotaManager2"></component></application>'
+    )
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("quota data unavailable")
+  })
+
+  it("parses P30D and P4W durations", async () => {
+    const ctx = makeCtx()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: { current: "50", maximum: "100", available: "50", until: "2099-01-31T00:00:00Z" },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "100", duration: "P30D" } },
+      })
+    )
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const quota = result.lines.find((line) => line.label === "Quota")
+    expect(quota && quota.periodDurationMs).toBe(30 * 24 * 60 * 60 * 1000)
+
+    delete globalThis.__openusage_plugin
+    vi.resetModules()
+    ctx.host.fs.writeText(
+      DARWIN_PATH,
+      makeQuotaXml({
+        quotaInfo: { current: "50", maximum: "100", available: "50", until: "2099-01-31T00:00:00Z" },
+        nextRefill: { type: "Known", next: "2099-01-01T00:00:00Z", tariff: { amount: "100", duration: "P4W" } },
+      })
+    )
+    const plugin2 = await loadPlugin()
+    const result2 = plugin2.probe(ctx)
+    const quota2 = result2.lines.find((line) => line.label === "Quota")
+    expect(quota2 && quota2.periodDurationMs).toBe(4 * 7 * 24 * 60 * 60 * 1000)
+  })
+})

package/plugins/kimi/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+  <path d="M11.065 11.199l7.257-7.2c.137-.136.06-.41-.116-.41H14.3a.164.164 0 0 0-.117.051l-7.82 7.756c-.122.12-.302.013-.302-.179V3.82c0-.127-.083-.23-.185-.23H3.186c-.103 0-.186.103-.186.23V19.77c0 .128.083.23.186.23h2.69c.103 0 .186-.102.186-.23v-3.25c0-.069.025-.135.069-.178l2.424-2.406a.158.158 0 0 1 .205-.023l6.484 4.772a7.677 7.677 0 0 0 3.453 1.283c.108.012.2-.095.2-.23v-3.06c0-.117-.07-.212-.164-.227a5.028 5.028 0 0 1-2.027-.807l-5.613-4.064c-.117-.078-.132-.279-.028-.381z" />
+</svg>

package/plugins/kimi/plugin.js

@@ -0,0 +1,358 @@
+(function () {
+  const CRED_PATH = "~/.kimi/credentials/kimi-code.json"
+  const USAGE_URL = "https://api.kimi.com/coding/v1/usages"
+  const REFRESH_URL = "https://auth.kimi.com/api/oauth/token"
+  const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
+  const REFRESH_BUFFER_SEC = 5 * 60
+
+  function readNumber(value) {
+    const n = Number(value)
+    return Number.isFinite(n) ? n : null
+  }
+
+  function titleCaseWords(value) {
+    return String(value)
+      .trim()
+      .toLowerCase()
+      .replace(/\b[a-z]/g, function (c) {
+        return c.toUpperCase()
+      })
+  }
+
+  function parsePlanLabel(data) {
+    const level =
+      data &&
+      data.user &&
+      data.user.membership &&
+      typeof data.user.membership.level === "string"
+        ? data.user.membership.level
+        : null
+    if (!level) return null
+
+    const cleaned = level.replace(/^LEVEL_/, "").replace(/_/g, " ")
+    const label = titleCaseWords(cleaned)
+    return label || null
+  }
+
+  function loadCredentials(ctx) {
+    if (!ctx.host.fs.exists(CRED_PATH)) {
+      ctx.host.log.warn("credentials file not found: " + CRED_PATH)
+      return null
+    }
+
+    try {
+      const text = ctx.host.fs.readText(CRED_PATH)
+      const parsed = ctx.util.tryParseJson(text)
+      if (!parsed || typeof parsed !== "object") {
+        ctx.host.log.warn("credentials file is not valid json")
+        return null
+      }
+      if (!parsed.access_token && !parsed.refresh_token) {
+        ctx.host.log.warn("credentials missing access_token and refresh_token")
+        return null
+      }
+      return parsed
+    } catch (e) {
+      ctx.host.log.warn("credentials read failed: " + String(e))
+      return null
+    }
+  }
+
+  function saveCredentials(ctx, creds) {
+    try {
+      ctx.host.fs.writeText(CRED_PATH, JSON.stringify(creds))
+    } catch (e) {
+      ctx.host.log.warn("failed to persist credentials: " + String(e))
+    }
+  }
+
+  function needsRefresh(creds, nowSec) {
+    if (!creds.access_token) return true
+    const expiresAt = readNumber(creds.expires_at)
+    if (expiresAt === null) return true
+    return nowSec + REFRESH_BUFFER_SEC >= expiresAt
+  }
+
+  function refreshToken(ctx, creds) {
+    if (!creds.refresh_token) {
+      ctx.host.log.warn("refresh skipped: no refresh token")
+      return null
+    }
+
+    ctx.host.log.info("attempting token refresh")
+    let resp
+    try {
+      resp = ctx.util.request({
+        method: "POST",
+        url: REFRESH_URL,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json",
+        },
+        bodyText:
+          "client_id=" +
+          encodeURIComponent(CLIENT_ID) +
+          "&grant_type=refresh_token" +
+          "&refresh_token=" +
+          encodeURIComponent(creds.refresh_token),
+        timeoutMs: 15000,
+      })
+    } catch (e) {
+      ctx.host.log.error("refresh exception: " + String(e))
+      return null
+    }
+
+    if (ctx.util.isAuthStatus(resp.status)) {
+      throw "Session expired. Run `kimi login` to authenticate."
+    }
+
+    if (resp.status < 200 || resp.status >= 300) {
+      ctx.host.log.warn("refresh returned unexpected status: " + resp.status)
+      return null
+    }
+
+    const body = ctx.util.tryParseJson(resp.bodyText)
+    if (!body || !body.access_token) {
+      ctx.host.log.warn("refresh response missing access_token")
+      return null
+    }
+
+    creds.access_token = body.access_token
+    if (body.refresh_token) creds.refresh_token = body.refresh_token
+    if (typeof body.expires_in === "number") {
+      creds.expires_at = Date.now() / 1000 + body.expires_in
+    }
+    if (typeof body.scope === "string") creds.scope = body.scope
+    if (typeof body.token_type === "string") creds.token_type = body.token_type
+
+    saveCredentials(ctx, creds)
+    return creds.access_token
+  }
+
+  function fetchUsage(ctx, accessToken) {
+    return ctx.util.request({
+      method: "GET",
+      url: USAGE_URL,
+      headers: {
+        Authorization: "Bearer " + accessToken,
+        Accept: "application/json",
+        "User-Agent": "OpenUsage",
+      },
+      timeoutMs: 10000,
+    })
+  }
+
+  function parseWindowPeriodMs(window) {
+    if (!window || typeof window !== "object") return null
+    const duration = readNumber(window.duration)
+    if (duration === null || duration <= 0) return null
+
+    const unit = String(window.timeUnit || window.time_unit || "").toUpperCase()
+    if (unit.indexOf("MINUTE") !== -1) return duration * 60 * 1000
+    if (unit.indexOf("HOUR") !== -1) return duration * 60 * 60 * 1000
+    if (unit.indexOf("DAY") !== -1) return duration * 24 * 60 * 60 * 1000
+    if (unit.indexOf("SECOND") !== -1) return duration * 1000
+    return null
+  }
+
+  function parseQuota(row, ctx) {
+    if (!row || typeof row !== "object") return null
+
+    const limit = readNumber(row.limit)
+    if (limit === null || limit <= 0) return null
+
+    let used = readNumber(row.used)
+    if (used === null) {
+      const remaining = readNumber(row.remaining)
+      if (remaining !== null) {
+        used = limit - remaining
+      }
+    }
+    if (used === null) return null
+
+    return {
+      used,
+      limit,
+      resetsAt: ctx.util.toIso(row.resetTime || row.reset_at || row.resetAt || row.reset_time),
+    }
+  }
+
+  function toPercentUsage(quota) {
+    if (!quota || quota.limit <= 0) return null
+    const usedPercent = (quota.used / quota.limit) * 100
+    if (!Number.isFinite(usedPercent)) return null
+    return {
+      used: Math.round(Math.max(0, usedPercent) * 10) / 10,
+      limit: 100,
+      resetsAt: quota.resetsAt,
+    }
+  }
+
+  function collectLimitCandidates(ctx, data) {
+    const limits = Array.isArray(data && data.limits) ? data.limits : []
+    const out = []
+
+    for (let i = 0; i < limits.length; i += 1) {
+      const item = limits[i]
+      const detail = item && typeof item.detail === "object" ? item.detail : item
+      const quota = parseQuota(detail, ctx)
+      if (!quota) continue
+
+      const periodMs = parseWindowPeriodMs(item && item.window)
+      out.push({ quota, periodMs })
+    }
+
+    return out
+  }
+
+  function pickSessionCandidate(candidates) {
+    if (!candidates.length) return null
+    const sorted = candidates.slice().sort(function (a, b) {
+      const aKnown = typeof a.periodMs === "number"
+      const bKnown = typeof b.periodMs === "number"
+      if (aKnown && bKnown) return a.periodMs - b.periodMs
+      if (aKnown) return -1
+      if (bKnown) return 1
+      return 0
+    })
+    return sorted[0]
+  }
+
+  function pickLargestByPeriod(candidates) {
+    if (!candidates.length) return null
+    let best = candidates[0]
+    for (let i = 1; i < candidates.length; i += 1) {
+      const cur = candidates[i]
+      const curMs = typeof cur.periodMs === "number" ? cur.periodMs : -1
+      const bestMs = typeof best.periodMs === "number" ? best.periodMs : -1
+      if (curMs > bestMs) best = cur
+    }
+    return best
+  }
+
+  function sameQuota(a, b) {
+    if (!a || !b) return false
+    return (
+      a.quota.used === b.quota.used &&
+      a.quota.limit === b.quota.limit &&
+      (a.quota.resetsAt || null) === (b.quota.resetsAt || null)
+    )
+  }
+
+  function probe(ctx) {
+    const creds = loadCredentials(ctx)
+    if (!creds) {
+      throw "Not logged in. Run `kimi login` to authenticate."
+    }
+
+    const nowSec = Date.now() / 1000
+    let accessToken = creds.access_token || ""
+
+    if (needsRefresh(creds, nowSec)) {
+      const refreshed = refreshToken(ctx, creds)
+      if (refreshed) {
+        accessToken = refreshed
+      } else if (!accessToken) {
+        throw "Not logged in. Run `kimi login` to authenticate."
+      }
+    }
+
+    let didRefresh = false
+    let resp
+    try {
+      resp = ctx.util.retryOnceOnAuth({
+        request: function (token) {
+          return fetchUsage(ctx, token || accessToken)
+        },
+        refresh: function () {
+          didRefresh = true
+          const refreshed = refreshToken(ctx, creds)
+          if (refreshed) accessToken = refreshed
+          return refreshed
+        },
+      })
+    } catch (e) {
+      if (typeof e === "string") throw e
+      if (didRefresh) {
+        throw "Usage request failed after refresh. Try again."
+      }
+      throw "Usage request failed. Check your connection."
+    }
+
+    if (ctx.util.isAuthStatus(resp.status)) {
+      throw "Token expired. Run `kimi login` to authenticate."
+    }
+    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 || typeof data !== "object") {
+      throw "Usage response invalid. Try again later."
+    }
+
+    const lines = []
+    const candidates = collectLimitCandidates(ctx, data)
+    const sessionCandidate = pickSessionCandidate(candidates)
+
+    let weeklyCandidate = null
+    const usageQuota = parseQuota(data.usage, ctx)
+    if (usageQuota) {
+      weeklyCandidate = { quota: usageQuota, periodMs: null }
+    } else {
+      const withoutSession = candidates.filter(function (candidate) {
+        return candidate !== sessionCandidate
+      })
+      weeklyCandidate = pickLargestByPeriod(withoutSession)
+    }
+
+    if (sessionCandidate) {
+      const sessionPercent = toPercentUsage(sessionCandidate.quota)
+      if (sessionPercent) {
+        lines.push(
+          ctx.line.progress({
+            label: "Session",
+            used: sessionPercent.used,
+            limit: sessionPercent.limit,
+            format: { kind: "percent" },
+            resetsAt: sessionPercent.resetsAt || undefined,
+            periodDurationMs:
+              typeof sessionCandidate.periodMs === "number"
+                ? sessionCandidate.periodMs
+                : undefined,
+          })
+        )
+      }
+    }
+
+    if (weeklyCandidate && !sameQuota(weeklyCandidate, sessionCandidate)) {
+      const weeklyPercent = toPercentUsage(weeklyCandidate.quota)
+      if (weeklyPercent) {
+        lines.push(
+          ctx.line.progress({
+            label: "Weekly",
+            used: weeklyPercent.used,
+            limit: weeklyPercent.limit,
+            format: { kind: "percent" },
+            resetsAt: weeklyPercent.resetsAt || undefined,
+            periodDurationMs:
+              typeof weeklyCandidate.periodMs === "number"
+                ? weeklyCandidate.periodMs
+                : undefined,
+          })
+        )
+      }
+    }
+
+    if (lines.length === 0) {
+      lines.push(ctx.line.badge({ label: "Status", text: "No usage data", color: "#a3a3a3" }))
+    }
+
+    return {
+      plan: parsePlanLabel(data),
+      lines,
+    }
+  }
+
+  globalThis.__openusage_plugin = { id: "kimi", probe }
+})()