openusage 0.1.0

package/plugins/windsurf/plugin.js

@@ -0,0 +1,218 @@
+(function () {
+  var LS_SERVICE = "exa.language_server_pb.LanguageServerService"
+
+  // Windsurf variants — tried in order (Windsurf first, then Windsurf Next).
+  // Markers use --ide_name exact matching in the Rust discover code.
+  var VARIANTS = [
+    {
+      marker: "windsurf",
+      ideName: "windsurf",
+      stateDb: "~/Library/Application Support/Windsurf/User/globalStorage/state.vscdb",
+    },
+    {
+      marker: "windsurf-next",
+      ideName: "windsurf-next",
+      stateDb: "~/Library/Application Support/Windsurf - Next/User/globalStorage/state.vscdb",
+    },
+  ]
+
+  // --- LS discovery ---
+
+  function discoverLs(ctx, variant) {
+    return ctx.host.ls.discover({
+      processName: "language_server_macos",
+      markers: [variant.marker],
+      csrfFlag: "--csrf_token",
+      portFlag: "--extension_server_port",
+      extraFlags: ["--windsurf_version"],
+    })
+  }
+
+  function loadApiKey(ctx, variant) {
+    try {
+      var rows = ctx.host.sqlite.query(
+        variant.stateDb,
+        "SELECT value FROM ItemTable WHERE key = 'windsurfAuthStatus' LIMIT 1"
+      )
+      var parsed = ctx.util.tryParseJson(rows)
+      if (!parsed || !parsed.length || !parsed[0].value) return null
+      var auth = ctx.util.tryParseJson(parsed[0].value)
+      if (!auth || !auth.apiKey) return null
+      return auth.apiKey
+    } catch (e) {
+      ctx.host.log.warn("failed to read API key from " + variant.marker + ": " + String(e))
+      return null
+    }
+  }
+
+  function probePort(ctx, scheme, port, csrf, ideName) {
+    ctx.host.http.request({
+      method: "POST",
+      url: scheme + "://127.0.0.1:" + port + "/" + LS_SERVICE + "/GetUnleashData",
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-codeium-csrf-token": csrf,
+      },
+      bodyText: JSON.stringify({
+        context: {
+          properties: {
+            devMode: "false",
+            extensionVersion: "unknown",
+            ide: ideName,
+            ideVersion: "unknown",
+            os: "macos",
+          },
+        },
+      }),
+      timeoutMs: 5000,
+      dangerouslyIgnoreTls: scheme === "https",
+    })
+    return true
+  }
+
+  function findWorkingPort(ctx, discovery, ideName) {
+    var ports = discovery.ports || []
+    for (var i = 0; i < ports.length; i++) {
+      var port = ports[i]
+      try { if (probePort(ctx, "https", port, discovery.csrf, ideName)) return { port: port, scheme: "https" } } catch (e) { /* ignore */ }
+      try { if (probePort(ctx, "http", port, discovery.csrf, ideName)) return { port: port, scheme: "http" } } catch (e) { /* ignore */ }
+      ctx.host.log.info("port " + port + " probe failed on both schemes")
+    }
+    if (discovery.extensionPort) return { port: discovery.extensionPort, scheme: "http" }
+    return null
+  }
+
+  function callLs(ctx, port, scheme, csrf, method, body) {
+    var resp = ctx.host.http.request({
+      method: "POST",
+      url: scheme + "://127.0.0.1:" + port + "/" + LS_SERVICE + "/" + method,
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-codeium-csrf-token": csrf,
+      },
+      bodyText: JSON.stringify(body || {}),
+      timeoutMs: 10000,
+      dangerouslyIgnoreTls: scheme === "https",
+    })
+    if (resp.status < 200 || resp.status >= 300) {
+      ctx.host.log.warn("callLs " + method + " returned " + resp.status)
+      return null
+    }
+    return ctx.util.tryParseJson(resp.bodyText)
+  }
+
+  // --- Credit line builder ---
+
+  function creditLine(ctx, label, used, total, resetsAt, periodMs) {
+    if (typeof total !== "number" || total <= 0) return null
+    if (typeof used !== "number") used = 0
+    if (used < 0) used = 0
+    var line = {
+      label: label,
+      used: used,
+      limit: total,
+      format: { kind: "count", suffix: "credits" },
+    }
+    if (resetsAt) line.resetsAt = resetsAt
+    if (periodMs) line.periodDurationMs = periodMs
+    return ctx.line.progress(line)
+  }
+
+  // --- LS probe for a specific variant ---
+
+  function probeVariant(ctx, variant) {
+    var discovery = discoverLs(ctx, variant)
+    if (!discovery) return null
+
+    var found = findWorkingPort(ctx, discovery, variant.ideName)
+    if (!found) return null
+
+    var apiKey = loadApiKey(ctx, variant)
+    if (!apiKey) {
+      ctx.host.log.warn("no API key found in SQLite for " + variant.marker)
+      return null
+    }
+
+    var version = (discovery.extra && discovery.extra.windsurf_version) || "unknown"
+
+    var metadata = {
+      apiKey: apiKey,
+      ideName: variant.ideName,
+      ideVersion: version,
+      extensionName: variant.ideName,
+      extensionVersion: version,
+      locale: "en",
+    }
+
+    var data = null
+    try {
+      data = callLs(ctx, found.port, found.scheme, discovery.csrf, "GetUserStatus", { metadata: metadata })
+    } catch (e) {
+      ctx.host.log.warn("GetUserStatus threw for " + variant.marker + ": " + String(e))
+    }
+
+    if (!data || !data.userStatus) return null
+
+    var us = data.userStatus
+    var ps = us.planStatus || {}
+    var pi = ps.planInfo || {}
+
+    var plan = pi.planName || null
+
+    // Billing cycle for pacing
+    var planEnd = ps.planEnd || null
+    var planStart = ps.planStart || null
+    var periodMs = null
+    if (planStart && planEnd) {
+      var startMs = Date.parse(planStart)
+      var endMs = Date.parse(planEnd)
+      if (Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs) {
+        periodMs = endMs - startMs
+      }
+    }
+
+    var lines = []
+
+    // API returns credits in hundredths (like cents) — divide by 100 for display
+    // Windsurf UI: "0/500 prompt credits" = API availablePromptCredits: 50000
+
+    // Prompt credits
+    var promptTotal = ps.availablePromptCredits
+    var promptUsed = ps.usedPromptCredits || 0
+    if (typeof promptTotal === "number" && promptTotal > 0) {
+      var pl = creditLine(ctx, "Prompt credits", promptUsed / 100, promptTotal / 100, planEnd, periodMs)
+      if (pl) lines.push(pl)
+    }
+
+    // Flex credits
+    var flexTotal = ps.availableFlexCredits
+    var flexUsed = ps.usedFlexCredits || 0
+    if (typeof flexTotal === "number" && flexTotal > 0) {
+      var xl = creditLine(ctx, "Flex credits", flexUsed / 100, flexTotal / 100, null, null)
+      if (xl) lines.push(xl)
+    }
+
+    if (lines.length === 0) {
+      // All credits unlimited (negative available) — still return plan, show badge
+      lines.push(ctx.line.badge({ label: "Credits", text: "Unlimited" }))
+    }
+
+    return { plan: plan, lines: lines }
+  }
+
+  // --- Probe ---
+
+  function probe(ctx) {
+    // Try each variant in order: Windsurf → Windsurf Next
+    for (var i = 0; i < VARIANTS.length; i++) {
+      var result = probeVariant(ctx, VARIANTS[i])
+      if (result) return result
+    }
+
+    throw "Start Windsurf and try again."
+  }
+
+  globalThis.__openusage_plugin = { id: "windsurf", probe: probe }
+})()

package/plugins/windsurf/plugin.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "id": "windsurf",
+  "name": "Windsurf",
+  "version": "0.0.1",
+  "entry": "plugin.js",
+  "icon": "icon.svg",
+  "brandColor": "#111111",
+  "cli": {
+    "category": "ide"
+  },
+  "lines": [
+    { "type": "progress", "label": "Prompt credits", "scope": "overview", "primaryOrder": 1 },
+    { "type": "progress", "label": "Flex credits", "scope": "overview" }
+  ]
+}

package/plugins/windsurf/plugin.test.js

@@ -0,0 +1,455 @@
+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
+}
+
+// --- Fixtures ---
+
+function makeDiscovery(overrides) {
+  return Object.assign(
+    { pid: 12345, csrf: "test-csrf", ports: [42001], extensionPort: null },
+    overrides
+  )
+}
+
+function makeAuthStatus(apiKey) {
+  return JSON.stringify([{ value: JSON.stringify({ apiKey: apiKey || "sk-ws-01-test" }) }])
+}
+
+function makeLsResponse(overrides) {
+  var base = {
+    userStatus: {
+      planStatus: {
+        planInfo: { planName: "Teams" },
+        planStart: "2026-01-18T09:07:17Z",
+        planEnd: "2026-02-18T09:07:17Z",
+        availablePromptCredits: 50000,
+        usedPromptCredits: 4700,
+        availableFlowCredits: 120000,
+        usedFlowCredits: 0,
+        availableFlexCredits: 2675000,
+        usedFlexCredits: 175550,
+      },
+    },
+  }
+  if (overrides) {
+    Object.assign(base.userStatus.planStatus, overrides)
+  }
+  return base
+}
+
+function setupLsMock(ctx, discovery, apiKey, responseBody, opts) {
+  var stateDb = (opts && opts.stateDb) || "Windsurf"
+  ctx.host.ls.discover.mockImplementation((discoverOpts) => {
+    // Match the right variant by marker
+    var marker = discoverOpts.markers[0]
+    if (marker === "windsurf" && stateDb === "Windsurf") return discovery
+    if (marker === "windsurf-next" && stateDb === "Windsurf - Next") return discovery
+    return null
+  })
+  ctx.host.sqlite.query.mockImplementation((db, sql) => {
+    if (String(sql).includes("windsurfAuthStatus") && String(db).includes(stateDb)) {
+      return makeAuthStatus(apiKey)
+    }
+    return "[]"
+  })
+  ctx.host.http.request.mockImplementation((reqOpts) => {
+    if (String(reqOpts.url).includes("GetUnleashData")) {
+      return { status: 200, bodyText: "{}" }
+    }
+    return { status: 200, bodyText: JSON.stringify(responseBody) }
+  })
+}
+
+// --- Tests ---
+
+describe("windsurf plugin", () => {
+  beforeEach(() => {
+    delete globalThis.__openusage_plugin
+    vi.resetModules()
+  })
+
+  it("throws when LS not found and no cache", async () => {
+    const ctx = makeCtx()
+    ctx.host.ls.discover.mockReturnValue(null)
+    ctx.host.sqlite.query.mockReturnValue("[]")
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Start Windsurf and try again.")
+  })
+
+  it("returns credits from LS with billing pacing", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse())
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    expect(result.plan).toBe("Teams")
+
+    // Values divided by 100 for display (API stores in hundredths)
+    const prompt = result.lines.find((l) => l.label === "Prompt credits")
+    expect(prompt).toBeTruthy()
+    expect(prompt.used).toBe(47)       // 4700 / 100
+    expect(prompt.limit).toBe(500)     // 50000 / 100
+    expect(prompt.resetsAt).toBe("2026-02-18T09:07:17Z")
+    expect(prompt.periodDurationMs).toBeGreaterThan(0)
+
+    expect(result.lines.find((l) => l.label === "Flow credits")).toBeFalsy()
+
+    const flex = result.lines.find((l) => l.label === "Flex credits")
+    expect(flex).toBeTruthy()
+    expect(flex.used).toBe(1755.5)     // 175550 / 100
+    expect(flex.limit).toBe(26750)     // 2675000 / 100
+    expect(flex.resetsAt).toBeUndefined()
+    expect(flex.periodDurationMs).toBeUndefined()
+  })
+
+  it("flex credits have no billing cycle (non-renewing)", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse())
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    const prompt = result.lines.find((l) => l.label === "Prompt credits")
+    expect(prompt.resetsAt).toBe("2026-02-18T09:07:17Z")
+    expect(prompt.periodDurationMs).toBeGreaterThan(0)
+
+    const flex = result.lines.find((l) => l.label === "Flex credits")
+    expect(flex.resetsAt).toBeUndefined()
+    expect(flex.periodDurationMs).toBeUndefined()
+  })
+
+  it("skips credit lines with negative available (unlimited)", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse({
+      availablePromptCredits: -1,
+      availableFlexCredits: 100000,
+      usedFlexCredits: 500,
+    }))
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    expect(result.lines.find((l) => l.label === "Prompt credits")).toBeFalsy()
+    expect(result.lines.find((l) => l.label === "Flex credits")).toBeTruthy()
+  })
+
+  it("sends apiKey in metadata", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-mykey", makeLsResponse())
+
+    let sentBody = null
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUserStatus")) {
+        sentBody = reqOpts.bodyText
+      }
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+    })
+
+    const plugin = await loadPlugin()
+    plugin.probe(ctx)
+
+    expect(sentBody).toBeTruthy()
+    const parsed = JSON.parse(sentBody)
+    expect(parsed.metadata.apiKey).toBe("sk-ws-01-mykey")
+    expect(parsed.metadata.ideName).toBe("windsurf")
+  })
+
+  it("returns null from LS when no API key", async () => {
+    const ctx = makeCtx()
+    ctx.host.ls.discover.mockReturnValue(makeDiscovery())
+    ctx.host.sqlite.query.mockReturnValue("[]")
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    // No API key → LS probe returns null → falls back to cache → no cache → throws
+    expect(() => plugin.probe(ctx)).toThrow("Start Windsurf and try again.")
+  })
+
+  it("calculates billing period duration from planStart/planEnd", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse())
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    const prompt = result.lines.find((l) => l.label === "Prompt credits")
+    expect(prompt.used).toBe(47) // 4700 / 100
+    const expected = Date.parse("2026-02-18T09:07:17Z") - Date.parse("2026-01-18T09:07:17Z")
+    expect(prompt.periodDurationMs).toBe(expected)
+  })
+
+  // --- Windsurf Next tests ---
+
+  it("falls back to Windsurf Next when Windsurf LS not found", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-next", makeLsResponse({
+      planInfo: { planName: "Pro" },
+    }), { stateDb: "Windsurf - Next" })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    expect(result.plan).toBe("Pro")
+  })
+
+  it("sends windsurf-next as ideName for Windsurf Next variant", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-next", makeLsResponse(), { stateDb: "Windsurf - Next" })
+
+    let sentBody = null
+    const origHttp = ctx.host.http.request
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUserStatus")) {
+        sentBody = reqOpts.bodyText
+      }
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+    })
+
+    const plugin = await loadPlugin()
+    plugin.probe(ctx)
+
+    expect(sentBody).toBeTruthy()
+    const parsed = JSON.parse(sentBody)
+    expect(parsed.metadata.ideName).toBe("windsurf-next")
+    expect(parsed.metadata.extensionName).toBe("windsurf-next")
+  })
+
+  it("reads API key from Windsurf Next SQLite path", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-next", makeLsResponse(), { stateDb: "Windsurf - Next" })
+
+    let queriedDb = null
+    ctx.host.sqlite.query.mockImplementation((db, sql) => {
+      if (String(sql).includes("windsurfAuthStatus")) {
+        queriedDb = db
+        return makeAuthStatus("sk-ws-01-next")
+      }
+      return "[]"
+    })
+
+    const plugin = await loadPlugin()
+    plugin.probe(ctx)
+
+    expect(queriedDb).toContain("Windsurf - Next")
+  })
+
+  it("prefers Windsurf over Windsurf Next when both available", async () => {
+    const ctx = makeCtx()
+    // Both variants return valid discoveries
+    ctx.host.ls.discover.mockImplementation((discoverOpts) => {
+      return makeDiscovery()
+    })
+    ctx.host.sqlite.query.mockImplementation((db, sql) => {
+      if (String(sql).includes("windsurfAuthStatus")) {
+        return makeAuthStatus("sk-ws-01-both")
+      }
+      return "[]"
+    })
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+    })
+
+    let sentBodies = []
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUserStatus")) {
+        sentBodies.push(reqOpts.bodyText)
+      }
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    // Should use windsurf (first variant) and never try windsurf-next
+    expect(sentBodies.length).toBe(1)
+    const parsed = JSON.parse(sentBodies[0])
+    expect(parsed.metadata.ideName).toBe("windsurf")
+  })
+
+  it("falls back from https to http when probing LS port", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse())
+
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      const url = String(reqOpts.url)
+      if (url.includes("GetUnleashData")) {
+        if (url.startsWith("https://")) throw new Error("self-signed cert")
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    expect(result.plan).toBe("Teams")
+    const unleashCalls = ctx.host.http.request.mock.calls
+      .map((call) => String(call[0]?.url))
+      .filter((url) => url.includes("GetUnleashData"))
+    expect(unleashCalls.some((url) => url.startsWith("http://"))).toBe(true)
+  })
+
+  it("uses extensionPort when direct probes fail for all discovered ports", async () => {
+    const ctx = makeCtx()
+    const discovery = makeDiscovery({ ports: [42001], extensionPort: 42002 })
+    setupLsMock(ctx, discovery, "sk-ws-01-test", makeLsResponse())
+
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      const url = String(reqOpts.url)
+      if (url.includes("GetUnleashData")) {
+        throw new Error("probe failed")
+      }
+      if (url.includes(":42002/") && url.includes("GetUserStatus")) {
+        return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+      }
+      return { status: 500, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBe("Teams")
+  })
+
+  it("returns unlimited badge when all credit buckets are non-positive", async () => {
+    const ctx = makeCtx()
+    setupLsMock(
+      ctx,
+      makeDiscovery(),
+      "sk-ws-01-test",
+      makeLsResponse({ availablePromptCredits: -1, availableFlexCredits: -1 })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+
+    expect(result.lines).toEqual([{ type: "badge", label: "Credits", text: "Unlimited" }])
+  })
+
+  it("clamps negative used credits to zero", async () => {
+    const ctx = makeCtx()
+    setupLsMock(
+      ctx,
+      makeDiscovery(),
+      "sk-ws-01-test",
+      makeLsResponse({ availablePromptCredits: 50000, usedPromptCredits: -500, availableFlexCredits: -1 })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const prompt = result.lines.find((l) => l.label === "Prompt credits")
+    expect(prompt.used).toBe(0)
+  })
+
+  it("omits billing period when plan dates are invalid", async () => {
+    const ctx = makeCtx()
+    setupLsMock(
+      ctx,
+      makeDiscovery(),
+      "sk-ws-01-test",
+      makeLsResponse({ planStart: "not-a-date", planEnd: "2026-02-18T09:07:17Z", availableFlexCredits: -1 })
+    )
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    const prompt = result.lines.find((l) => l.label === "Prompt credits")
+    expect(prompt.periodDurationMs).toBeUndefined()
+  })
+
+  it("throws when GetUserStatus returns non-2xx", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery(), "sk-ws-01-test", makeLsResponse())
+
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 500, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Start Windsurf and try again.")
+  })
+
+  it("treats missing apiKey in SQLite auth payload as unavailable", async () => {
+    const ctx = makeCtx()
+    ctx.host.ls.discover.mockReturnValue(makeDiscovery())
+    ctx.host.sqlite.query.mockReturnValue(JSON.stringify([{ value: JSON.stringify({}) }]))
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        return { status: 200, bodyText: "{}" }
+      }
+      return { status: 200, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Start Windsurf and try again.")
+  })
+
+  it("uses extensionPort when ports list is missing", async () => {
+    const ctx = makeCtx()
+    const discovery = makeDiscovery({ ports: undefined, extensionPort: 42002 })
+    setupLsMock(ctx, discovery, "sk-ws-01-test", makeLsResponse())
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      const url = String(reqOpts.url)
+      if (url.includes(":42002/") && url.includes("GetUserStatus")) {
+        return { status: 200, bodyText: JSON.stringify(makeLsResponse()) }
+      }
+      if (url.includes("GetUnleashData")) {
+        return { status: 500, bodyText: "{}" }
+      }
+      return { status: 500, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBe("Teams")
+  })
+
+  it("fails when all probes fail and extensionPort is absent", async () => {
+    const ctx = makeCtx()
+    const discovery = makeDiscovery({ ports: [42001], extensionPort: null })
+    setupLsMock(ctx, discovery, "sk-ws-01-test", makeLsResponse())
+    ctx.host.http.request.mockImplementation((reqOpts) => {
+      if (String(reqOpts.url).includes("GetUnleashData")) {
+        throw new Error("probe failed")
+      }
+      return { status: 500, bodyText: "{}" }
+    })
+
+    const plugin = await loadPlugin()
+    expect(() => plugin.probe(ctx)).toThrow("Start Windsurf and try again.")
+  })
+
+  it("handles sparse userStatus payload and returns unlimited badge", async () => {
+    const ctx = makeCtx()
+    setupLsMock(ctx, makeDiscovery({ extra: null }), "sk-ws-01-test", { userStatus: {} })
+
+    const plugin = await loadPlugin()
+    const result = plugin.probe(ctx)
+    expect(result.plan).toBeNull()
+    expect(result.lines).toEqual([{ type: "badge", label: "Credits", text: "Unlimited" }])
+  })
+
+})

package/plugins/zai/icon.svg

@@ -0,0 +1,5 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M51.57 23.67l-4.33 6.17c-0.67 0.97-1.80 1.57-3.00 1.57H20.57V23.63C20.53 23.67 51.57 23.67 51.57 23.67z" fill="currentColor"/>
+<polygon points="81.00,23.67 43.80,76.37 19.00,76.37 56.20,23.67" fill="currentColor"/>
+<path d="M48.43 76.37l4.37-6.20c0.67-0.97 1.80-1.57 3.00-1.57h23.63v7.77H48.43z" fill="currentColor"/>
+</svg>