@hashimkarim/usagestat-linux-x64-gnu 2.0.0-alpha.1 → 2.0.0-alpha.3

package/plugins/notion/plugin.js

@@ -0,0 +1,282 @@
+(function () {
+  var BASE_URL = "https://app.notion.com";
+  var GET_SPACES_URL = "https://app.notion.com/api/v3/getSpaces";
+  var RATE_LIMIT_URL = "https://app.notion.com/api/v3/getCreditRateLimitStatus";
+  var SESSION_COOKIE_NAME = "token_v2";
+  var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36";
+
+  function trim(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+  }
+
+  function env(ctx, name) {
+    try {
+      return trim(ctx.host.env.get(name));
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function setting(ctx, names) {
+    var settings = ctx.provider && ctx.provider.settings ? ctx.provider.settings : {};
+    for (var i = 0; i < names.length; i++) {
+      var value = trim(settings[names[i]]);
+      if (value) return value;
+    }
+    return null;
+  }
+
+  function normalizeCookie(raw) {
+    var value = trim(raw);
+    if (!value) return null;
+    if (value.slice(0, 7).toLowerCase() === "cookie:") value = value.slice(7).trim();
+    if (!value) return null;
+    if (value.indexOf("=") < 0) return SESSION_COOKIE_NAME + "=" + value;
+    var pairs = [];
+    var chunks = value.split(";");
+    for (var i = 0; i < chunks.length; i++) {
+      var idx = chunks[i].indexOf("=");
+      if (idx < 0) continue;
+      var name = chunks[i].slice(0, idx).trim();
+      var val = chunks[i].slice(idx + 1).trim();
+      if (name && val) pairs.push(name + "=" + val);
+    }
+    return pairs.length ? pairs.join("; ") : null;
+  }
+
+  function cookieHeader(ctx) {
+    return normalizeCookie(ctx.provider && ctx.provider.cookieHeader) ||
+      normalizeCookie(setting(ctx, ["cookieHeader", "cookie", "token"])) ||
+      normalizeCookie(env(ctx, "NOTION_COOKIE"));
+  }
+
+  function spaceOverride(ctx) {
+    return setting(ctx, ["spaceId", "workspaceId", "workspace"]) ||
+      trim(ctx.provider && ctx.provider.workspaceId) ||
+      env(ctx, "NOTION_SPACE_ID");
+  }
+
+  function requestJson(ctx, url, cookie, body) {
+    var result = ctx.util.requestJson({
+      method: "POST",
+      url: url,
+      headers: {
+        Cookie: cookie,
+        "Content-Type": "application/json",
+        Accept: "*/*",
+        "Accept-Language": "en-US,en;q=0.9",
+        "User-Agent": USER_AGENT,
+        Referer: BASE_URL + "/",
+        Origin: BASE_URL,
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Site": "same-origin",
+      },
+      bodyText: JSON.stringify(body || {}),
+      timeoutMs: 15000,
+    });
+    if (result.resp.status === 401) throw "Notion login required.";
+    if (result.resp.status < 200 || result.resp.status >= 300) throw "Notion API error: HTTP " + result.resp.status + ".";
+    if (!result.json || typeof result.json !== "object") throw "Could not parse Notion usage.";
+    return result.json;
+  }
+
+  function unwrapRecord(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+    var value = raw.value && typeof raw.value === "object" ? raw.value : raw;
+    if (value.value && typeof value.value === "object" && !Array.isArray(value.value)) return value.value;
+    return value;
+  }
+
+  function resolveUserId(root) {
+    var ids = [];
+    var keys = Object.keys(root || {});
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      var container = root[key];
+      var users = container && container.notion_user;
+      var record = users && unwrapRecord(users[key]);
+      if (record && record.id === key) ids.push(key);
+    }
+    if (ids.length === 1) return ids[0];
+    return keys.length === 1 ? keys[0] : null;
+  }
+
+  function normalizeSpaceId(raw) {
+    var text = trim(raw);
+    if (!text) return null;
+    var compact = text.replace(/-/g, "").toLowerCase();
+    if (/^[0-9a-f]{32}$/.test(compact)) {
+      return compact.slice(0, 8) + "-" + compact.slice(8, 12) + "-" + compact.slice(12, 16) + "-" +
+        compact.slice(16, 20) + "-" + compact.slice(20);
+    }
+    return text.toLowerCase();
+  }
+
+  function parseSpaces(json) {
+    var root = json && typeof json === "object" && !Array.isArray(json) ? json : null;
+    if (!root) throw "getSpaces response is not a JSON object.";
+    var userId = resolveUserId(root);
+    if (!userId || !root[userId]) throw "getSpaces response did not identify a single user.";
+    var container = root[userId];
+    var email = null;
+    var users = container.notion_user || {};
+    var record = unwrapRecord(users[userId]);
+    if (!record) {
+      var userKeys = Object.keys(users);
+      for (var i = 0; i < userKeys.length && !record; i++) record = unwrapRecord(users[userKeys[i]]);
+    }
+    if (record && typeof record.email === "string") email = record.email;
+
+    var spaces = [];
+    var spaceObj = container.space || {};
+    var spaceKeys = Object.keys(spaceObj).sort();
+    for (var j = 0; j < spaceKeys.length; j++) {
+      var key = spaceKeys[j];
+      var ws = unwrapRecord(spaceObj[key]);
+      if (!ws) continue;
+      spaces.push({
+        id: String(ws.id || key),
+        name: trim(ws.name),
+        tier: trim(ws.subscription_tier),
+      });
+    }
+    return { email: email, workspaces: spaces };
+  }
+
+  function mayHaveAllowance(workspace) {
+    var tier = String(workspace && workspace.tier || "").toLowerCase();
+    return tier === "business" || tier === "enterprise";
+  }
+
+  function pickWorkspace(account, preferredId) {
+    var preferred = normalizeSpaceId(preferredId);
+    if (preferred) {
+      for (var i = 0; i < account.workspaces.length; i++) {
+        if (normalizeSpaceId(account.workspaces[i].id) === preferred) return account.workspaces[i];
+      }
+      throw "Selected Notion workspace was not found in this account.";
+    }
+    for (var j = 0; j < account.workspaces.length; j++) {
+      if (mayHaveAllowance(account.workspaces[j])) return account.workspaces[j];
+    }
+    return account.workspaces[0] || null;
+  }
+
+  function title(value) {
+    var text = trim(value);
+    return text ? text.charAt(0).toUpperCase() + text.slice(1) : null;
+  }
+
+  function number(value) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      var parsed = Number(value.replace(/,/g, ""));
+      if (Number.isFinite(parsed)) return parsed;
+    }
+    return null;
+  }
+
+  function percent(used, limit) {
+    used = number(used);
+    limit = number(limit);
+    if (used === null || limit === null || limit <= 0) return null;
+    return Math.max(0, used / limit * 100);
+  }
+
+  function minutesFromWindow(raw) {
+    var text = String(raw || "").trim().toLowerCase();
+    var match = /^(\d+)([mhdw])$/.exec(text);
+    if (!match) return null;
+    var n = Number(match[1]);
+    if (!n) return null;
+    if (match[2] === "m") return n;
+    if (match[2] === "h") return n * 60;
+    if (match[2] === "d") return n * 24 * 60;
+    return n * 7 * 24 * 60;
+  }
+
+  function rollingReset(ctx, seconds) {
+    var n = number(seconds);
+    if (n === null || n < 0) return null;
+    return ctx.util.toIso(Date.parse(ctx.nowIso) + n * 1000);
+  }
+
+  function dateFromMs(value) {
+    var n = number(value);
+    if (n === null || n <= 0) return null;
+    var date = new Date(n);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+  }
+
+  function parseRateLimit(json) {
+    return {
+      status: trim(json && json.status),
+      window: json && json.window && typeof json.window === "object" ? json.window : null,
+      billing: json && json.billingPeriodWindow && typeof json.billingPeriodWindow === "object" ? json.billingPeriodWindow : null,
+      resetsInSeconds: number(json && json.resetsInSeconds),
+    };
+  }
+
+  function buildSnapshot(ctx, rateLimit, workspace, account) {
+    if (rateLimit.status && rateLimit.status.toLowerCase() === "not_applicable") {
+      throw "Notion AI usage allowance is not tracked for " + (workspace.name || "this workspace") + ".";
+    }
+    var lines = [];
+    if (rateLimit.window) {
+      var pct = percent(rateLimit.window.used, rateLimit.window.limit);
+      if (pct !== null) {
+        var minutes = minutesFromWindow(rateLimit.window.window);
+        var opts = {
+          label: "Rolling",
+          used: Math.max(0, Math.min(100, pct)),
+          limit: 100,
+          format: { kind: "percent" },
+        };
+        if (minutes && minutes !== 30 * 24 * 60) opts.periodDurationMs = minutes * 60 * 1000;
+        var rolling = rollingReset(ctx, rateLimit.resetsInSeconds);
+        if (rolling) opts.resetsAt = rolling;
+        lines.push(ctx.line.progress(opts));
+      }
+    }
+    if (rateLimit.billing) {
+      var bpct = percent(rateLimit.billing.used, rateLimit.billing.limit);
+      if (bpct !== null) {
+        var bopts = {
+          label: "Monthly",
+          used: Math.max(0, Math.min(100, bpct)),
+          limit: 100,
+          format: { kind: "percent" },
+        };
+        var reset = dateFromMs(rateLimit.billing.periodEndMs);
+        if (reset) {
+          bopts.resetsAt = reset;
+          bopts.periodDurationMs = ctx.util.calendarMonthDuration(reset);
+        }
+        var start = dateFromMs(rateLimit.billing.periodStartMs);
+        if (reset && start && Date.parse(reset) > Date.parse(start)) bopts.periodDurationMs = Date.parse(reset) - Date.parse(start);
+        lines.push(ctx.line.progress(bopts));
+      }
+    }
+    if (!lines.length) throw "getCreditRateLimitStatus returned no measurable usage windows.";
+    if (account.email) lines.push(ctx.line.text({ label: "Account", value: account.email }));
+    return {
+      displayName: "Notion AI",
+      source: "web",
+      plan: title(workspace.tier),
+      lines: lines,
+    };
+  }
+
+  function probe(ctx) {
+    var cookie = cookieHeader(ctx);
+    if (!cookie) throw "Notion session not configured. Set NOTION_COOKIE or provider cookieHeader.";
+    var account = parseSpaces(requestJson(ctx, GET_SPACES_URL, cookie, {}));
+    var workspace = pickWorkspace(account, spaceOverride(ctx));
+    if (!workspace) throw "No Notion workspace found for this account.";
+    var rateLimit = parseRateLimit(requestJson(ctx, RATE_LIMIT_URL, cookie, { spaceId: workspace.id }));
+    return buildSnapshot(ctx, rateLimit, workspace, account);
+  }
+
+  globalThis.__openusage_plugin = { id: "notion", probe: probe };
+})();

package/plugins/notion/plugin.json

@@ -0,0 +1,29 @@
+{
+  "schemaVersion": 1,
+  "id": "notion",
+  "name": "Notion AI",
+  "version": "0.1.0",
+  "entry": "plugin.js",
+  "enabledByDefault": false,
+  "supportedModes": [
+    "web"
+  ],
+  "autoMode": "web",
+  "webUrl": "https://app.notion.com",
+  "usageDashboardUrl": "https://app.notion.com/",
+  "statusPageUrl": "https://status.notion.so",
+  "links": [
+    {
+      "label": "Dashboard",
+      "url": "https://app.notion.com/"
+    },
+    {
+      "label": "Status",
+      "url": "https://status.notion.so"
+    }
+  ],
+  "envVars": [
+    "NOTION_COOKIE",
+    "NOTION_SPACE_ID"
+  ]
+}

package/plugins/ollama/plugin.js

@@ -1,92 +1,293 @@
 (function () {
-  var SETTINGS_URL = "https://ollama.com/settings"
-  var SESSION_COOKIE = "__Secure-session"
+  var SETTINGS_URL = "https://ollama.com/settings";
+  var TAGS_URL = "https://ollama.com/api/tags";
+  var VALIDATION_URL = "https://ollama.com/api/web_search";
+  var SESSION_COOKIE = "__Secure-session";
+  var SESSION_MS = 5 * 60 * 60 * 1000;
+  var WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 
-  function getCookieHeader(ctx) {
-    var raw = ctx.host.env.get("OLLAMA_COOKIE")
-    if (!raw || !raw.trim()) {
-      throw "Set OLLAMA_COOKIE to your " + SESSION_COOKIE + " cookie value from ollama.com/settings."
+  function clean(value) {
+    if (typeof value !== "string") return null;
+    var v = value.trim();
+    if (!v) return null;
+    if (
+      v.length >= 2 &&
+      ((v.charAt(0) === '"' && v.charAt(v.length - 1) === '"') ||
+        (v.charAt(0) === "'" && v.charAt(v.length - 1) === "'"))
+    ) {
+      v = v.slice(1, -1).trim();
+    }
+    return v || null;
+  }
+
+  function env(ctx, name) {
+    try {
+      return clean(ctx.host.env.get(name));
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function setting(ctx, names) {
+    var settings = ctx.provider && ctx.provider.settings ? ctx.provider.settings : {};
+    for (var i = 0; i < names.length; i++) {
+      var value = clean(settings[names[i]]);
+      if (value) return value;
+    }
+    return null;
+  }
+
+  function getApiKey(ctx) {
+    return clean(ctx.provider && ctx.provider.apiKey) ||
+      setting(ctx, ["apiKey", "ollamaApiKey"]) ||
+      env(ctx, "OLLAMA_API_KEY") ||
+      env(ctx, "OLLAMA_KEY");
+  }
+
+  function getCookieHeader(ctx, optional) {
+    var raw = clean(ctx.provider && ctx.provider.cookieHeader) ||
+      setting(ctx, ["cookieHeader", "cookie"]) ||
+      env(ctx, "OLLAMA_COOKIE");
+    if (!raw) {
+      if (optional) return null;
+      throw "Set OLLAMA_COOKIE to your " + SESSION_COOKIE + " cookie value from ollama.com/settings.";
+    }
+    var val = raw;
+    if (val.toLowerCase().slice(0, 5) === "curl ") {
+      var cookieMatch = val.match(/(?:^|\s)-H\s+['"]Cookie:\s*([^'"]+)['"]/i) ||
+        val.match(/(?:^|\s)--header\s+['"]Cookie:\s*([^'"]+)['"]/i);
+      if (cookieMatch) val = cookieMatch[1].trim();
     }
-    var val = raw.trim()
-    // Strip optional "cookie:" prefix
     if (val.toLowerCase().slice(0, 7) === "cookie:") {
-      val = val.slice(7).trim()
+      val = val.slice(7).trim();
     }
-    // If just a bare token value with no key=value format, wrap it
     if (val.indexOf("=") < 0) {
-      return SESSION_COOKIE + "=" + val
+      return SESSION_COOKIE + "=" + val;
+    }
+    return val;
+  }
+
+  function request(ctx, req) {
+    try {
+      return ctx.host.http.request(req);
+    } catch (e) {
+      ctx.host.log.warn("Ollama request failed: " + String(e));
+      throw "Ollama request failed. Check your connection.";
+    }
+  }
+
+  function parseJson(ctx, text) {
+    var parsed = ctx.util && typeof ctx.util.tryParseJson === "function"
+      ? ctx.util.tryParseJson(text)
+      : null;
+    if (!parsed && text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch (_) {}
+    }
+    return parsed;
+  }
+
+  function probeApi(ctx, apiKey) {
+    var validation = request(ctx, {
+      method: "POST",
+      url: VALIDATION_URL,
+      headers: {
+        Authorization: "Bearer " + apiKey,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "usagestat/" + String(ctx.app && ctx.app.version ? ctx.app.version : "0.0.0"),
+      },
+      bodyText: '{"query":""}',
+      timeoutMs: 15000,
+    });
+    if (validation.status === 401 || validation.status === 403) {
+      throw "Ollama API key is invalid or revoked.";
+    }
+    if (validation.status !== 200 && validation.status !== 400) {
+      throw "Ollama API validation returned HTTP " + validation.status + ".";
+    }
+
+    var tags = request(ctx, {
+      method: "GET",
+      url: TAGS_URL,
+      headers: {
+        Authorization: "Bearer " + apiKey,
+        Accept: "application/json",
+        "User-Agent": "usagestat/" + String(ctx.app && ctx.app.version ? ctx.app.version : "0.0.0"),
+      },
+      timeoutMs: 15000,
+    });
+    if (tags.status === 401 || tags.status === 403) {
+      throw "Ollama API key is invalid or revoked.";
+    }
+    if (tags.status < 200 || tags.status >= 300) {
+      throw "Ollama API returned HTTP " + tags.status + ".";
     }
-    return val
+    var parsed = parseJson(ctx, tags.bodyText);
+    if (!parsed || !Array.isArray(parsed.models)) {
+      throw "Ollama API tags response was not valid JSON.";
+    }
+
+    return {
+      displayName: "Ollama",
+      source: "api",
+      plan: "API key",
+      lines: [
+        ctx.line.text({
+          label: "Cloud Models",
+          value: String(parsed.models.length) + " available",
+        }),
+        ctx.line.badge({
+          label: "Status",
+          text: "API key valid; quota unavailable",
+          color: "#22c55e",
+        }),
+      ],
+    };
   }
 
-  function parsePercent(html, labels) {
+  function blockEnd(html, start, currentLabel) {
+    var labels = ["Monthly usage", "Session usage", "Hourly usage", "Weekly usage"];
+    var end = html.length;
     for (var i = 0; i < labels.length; i++) {
-      var idx = html.indexOf(labels[i])
-      if (idx < 0) continue
-      var window = html.slice(idx, idx + 800)
+      if (labels[i] === currentLabel) continue;
+      var idx = html.indexOf(labels[i], start + currentLabel.length);
+      if (idx >= 0 && idx < end) end = idx;
+    }
+    return Math.min(end, start + 4000);
+  }
+
+  function stripHtmlEntities(value) {
+    return String(value || "")
+      .replace(/&nbsp;/g, " ")
+      .replace(/&amp;/g, "&")
+      .replace(/&#x2F;/g, "/")
+      .replace(/\s+/g, " ")
+      .trim();
+  }
 
-      var usedMatch = window.match(/(\d+(?:\.\d+)?)\s*%\s*used/)
-      if (usedMatch) return parseFloat(usedMatch[1])
+  function parseIso(segment) {
+    var match = String(segment || "").match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/);
+    if (!match) return null;
+    var ms = Date.parse(match[0]);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+  }
+
+  function parseResetDescription(segment) {
+    var match = String(segment || "").match(/(resets?\s+in\s+[^<\n\r]+|reset\s+[^<\n\r]+)/i);
+    return match ? stripHtmlEntities(match[1]) : null;
+  }
 
-      var widthMatch = window.match(/width:\s*(\d+(?:\.\d+)?)%/)
-      if (widthMatch) return parseFloat(widthMatch[1])
+  function parseUsageBlock(html, labels, periodMs) {
+    for (var i = 0; i < labels.length; i++) {
+      var label = labels[i];
+      var idx = html.indexOf(label);
+      if (idx < 0) continue;
+      var segment = html.slice(idx, blockEnd(html, idx, label));
+      var usedMatch = segment.match(/(\d+(?:\.\d+)?)\s*%\s*used/i);
+      var dollars = segment.match(/\$((?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?)\s+of\s+\$((?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?)\s+used/i);
+      var widthMatch = segment.match(/width:\s*(\d+(?:\.\d+)?)%/i);
+      var value = usedMatch ? parseFloat(usedMatch[1]) : null;
+      if (value === null && dollars) {
+        var spent = Number(dollars[1].replace(/,/g, ""));
+        var cap = Number(dollars[2].replace(/,/g, ""));
+        if (Number.isFinite(spent) && Number.isFinite(cap) && cap > 0) value = spent / cap * 100;
+      }
+      if (!Number.isFinite(value) && widthMatch) value = parseFloat(widthMatch[1]);
+      if (Number.isFinite(value)) {
+        return {
+          used: Math.max(0, Math.min(100, value)),
+          resetsAt: parseIso(segment),
+          detail: parseResetDescription(segment),
+          periodMs: label === "Hourly usage" ? null : periodMs,
+        };
+      }
     }
-    return null
+    return null;
   }
 
-  function probe(ctx) {
-    var cookieHeader = getCookieHeader(ctx)
+  function progress(ctx, label, block) {
+    var line = {
+      label: label,
+      used: block.used,
+      limit: 100,
+      format: { kind: "percent" },
+    };
+    if (block.periodMs) line.periodDurationMs = block.periodMs;
+    if (block.resetsAt) line.resetsAt = block.resetsAt;
+    if (block.detail) line.detail = block.detail;
+    return ctx.line.progress(line);
+  }
 
-    var resp = ctx.host.http.request({
+  function probeWeb(ctx) {
+    var cookieHeader = getCookieHeader(ctx);
+    var resp = request(ctx, {
       method: "GET",
       url: SETTINGS_URL,
       headers: {
-        "Cookie": cookieHeader,
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
+        Cookie: cookieHeader,
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/143.0.0.0 Safari/537.36",
       },
       timeoutMs: 20000,
-    })
+    });
 
     if (resp.status === 401 || resp.status === 403) {
-      throw "Session expired. Update OLLAMA_COOKIE with a fresh session token."
+      throw "Session expired. Update OLLAMA_COOKIE with a fresh session token.";
     }
 
-    var html = resp.bodyText || ""
-
-    if (!html.includes("Session usage") && !html.includes("Weekly usage") && !html.includes("Cloud Usage")) {
+    var html = resp.bodyText || "";
+    if (!html.includes("Monthly usage") && !html.includes("Session usage") && !html.includes("Weekly usage") && !html.includes("Cloud Usage")) {
       if (html.includes("Sign in") || resp.status !== 200) {
-        throw "Session expired. Update OLLAMA_COOKIE with a fresh session token."
+        throw "Session expired. Update OLLAMA_COOKIE with a fresh session token.";
       }
     }
 
-    var sessionPct = parsePercent(html, ["Session usage", "Hourly usage"])
-    var weeklyPct = parsePercent(html, ["Weekly usage"])
+    var monthly = parseUsageBlock(html, ["Monthly usage"], null);
+    if (monthly && monthly.resetsAt) monthly.periodMs = ctx.util.calendarMonthDuration(monthly.resetsAt);
+    var session = parseUsageBlock(html, ["Session usage", "Hourly usage"], SESSION_MS);
+    var weekly = parseUsageBlock(html, ["Weekly usage"], WEEK_MS);
 
-    if (sessionPct === null && weeklyPct === null) {
-      throw "Could not find usage data on Ollama settings page."
+    if (!monthly && !session && !weekly) {
+      throw "Could not find usage data on Ollama settings page.";
     }
 
-    var lines = []
-    if (sessionPct !== null) {
-      lines.push(ctx.line.progress({
-        label: "Session",
-        used: sessionPct,
-        limit: 100,
-        format: { kind: "percent" },
-      }))
+    var lines = [];
+    if (monthly) lines.push(progress(ctx, "Monthly credits", monthly));
+    if (session) lines.push(progress(ctx, "Session", session));
+    if (weekly) lines.push(progress(ctx, "Weekly", weekly));
+
+    var planMatch = html.match(/(?:Included usage|Cloud Usage)\s*<\/span>\s*<span[^>]*>([^<]+)<\/span/i);
+    return {
+      displayName: "Ollama",
+      source: "web",
+      plan: planMatch ? stripHtmlEntities(planMatch[1]) : undefined,
+      lines: lines,
+    };
+  }
+
+  function probe(ctx) {
+    var source = String(ctx.sourceMode || "auto").toLowerCase();
+    var apiKey = getApiKey(ctx);
+    if (source === "api") {
+      if (!apiKey) throw "Missing Ollama API key. Set OLLAMA_API_KEY.";
+      return probeApi(ctx, apiKey);
     }
-    if (weeklyPct !== null) {
-      lines.push(ctx.line.progress({
-        label: "Weekly",
-        used: weeklyPct,
-        limit: 100,
-        format: { kind: "percent" },
-      }))
+    if (source === "web") return probeWeb(ctx);
+    if (getCookieHeader(ctx, true)) {
+      try {
+        return probeWeb(ctx);
+      } catch (e) {
+        if (!apiKey) throw e;
+        ctx.host.log.warn("Ollama settings unavailable; checking API access.");
+      }
     }
-
-    return { lines: lines }
+    if (apiKey) {
+      return probeApi(ctx, apiKey);
+    }
+    return probeWeb(ctx);
   }
 
-  globalThis.__openusage_plugin = { id: "ollama", probe: probe }
-})()
+  globalThis.__openusage_plugin = { id: "ollama", probe: probe };
+})();

package/plugins/ollama/plugin.json

@@ -8,13 +8,16 @@
   "links": [
     { "label": "Settings", "url": "https://ollama.com/settings" }
   ],
-  "envVars": ["OLLAMA_COOKIE"],
-  "supportedModes": ["web"],
+  "envVars": ["OLLAMA_COOKIE", "OLLAMA_API_KEY", "OLLAMA_KEY"],
+  "supportedModes": ["api", "web"],
   "autoMode": "web",
   "webUrl": "https://ollama.com",
   "usageDashboardUrl": "https://ollama.com/settings",
   "lines": [
     { "type": "progress", "label": "Session", "scope": "overview" },
-    { "type": "progress", "label": "Weekly", "scope": "detail" }
+    { "type": "progress", "label": "Weekly", "scope": "detail" },
+    { "type": "progress", "label": "Monthly credits", "scope": "overview" },
+    { "type": "text", "label": "Cloud Models", "scope": "detail" },
+    { "type": "badge", "label": "Status", "scope": "detail" }
   ]
 }