pi-provider-qoder-cn 0.2.0 → 0.2.2

package/README.md

@@ -64,14 +64,18 @@ export QODERCN_PERSONAL_ACCESS_TOKEN="<your PAT>"
 
 ### `/qoder-cn.usage`
 
-Shows the plan allowance and any purchased add-on credits.
+Shows the plan allowance and any purchased add-on credits as one aligned grid.
+In a terminal the gauge is coloured by how much of the allowance is gone —
+green under 60%, yellow to 85%, red above that, and bold red once the quota is
+exceeded.
 
 ```text
 Qoder CN Plan (personal_standard)
-[--------------------] 0% used
-  [--------------------] Add-on quota: 0 credits / 700 credits used (0%) · 700 credits left
-Resets: never
-Manage: https://qoder.com.cn/account/usage
+Overall     [███░░░░░░░░░░░░░░░░░░]                      12.5%  used
+Plan quota  [███░░░░░░░░░░░░░░░░░░]  250 / 2000 credits  12.5%  1750 left
+Add-on      [░░░░░░░░░░░░░░░░░░░░░]    0 /  700 credits     0%   700 left
+Resets      never
+Manage      https://qoder.com.cn/account/usage
 ```
 
 Append `json` to print the untouched API payload — useful when a field you need
@@ -81,13 +85,24 @@ is not in the formatted view:
 /qoder-cn.usage json
 ```
 
+Append `plain` for the same grid without the colour codes, e.g. when pasting it
+into an issue:
+
+```text
+/qoder-cn.usage plain
+```
+
 Notes:
 
-- The plan allowance (`Plan quota`) and top-up credits (`Add-on quota`) are
+- The plan allowance (`Plan quota`) and top-up credits (`Add-on`) are
   independent buckets with independent expiry, so both are listed when present.
-- `Resets: never` means the API reported the year-9999 sentinel, i.e. the
+  Columns are sized to the rows that came back, so a single-bucket plan does
+  not reserve space for one it does not have.
+- Colour is suppressed automatically for a `NO_COLOR` environment, a dumb
+  terminal, and any non-TTY output that is not the interactive UI.
+- `Resets never` means the API reported the year-9999 sentinel, i.e. the
   allowance does not reset on a schedule.
-- `(plan quota is prorated)` appears after a mid-cycle plan change.
+- `Note  plan quota is prorated` appears after a mid-cycle plan change.
 - The command uses the same stored token as chat requests, refreshing it first,
   so it reports the same quota the model is actually billed against.
 

package/dist/index.js

@@ -1719,11 +1719,37 @@ To reset: /qoder-endpoint default`,
 
 // src/commands/usage.ts
 init_region();
-function usageBar(percentage, width = 20) {
-  if (typeof percentage !== "number" || !Number.isFinite(percentage)) return `[${"?".repeat(width)}]`;
-  const ratio = Math.max(0, Math.min(1, percentage / 100));
-  const filled = Math.max(0, Math.min(width, Math.round(ratio * width)));
-  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var FILLED_CHAR = "\u2588";
+var EMPTY_CHAR = "\u2591";
+var UNKNOWN_CHAR = "?";
+var BAR_WIDTH = 20;
+var COLUMN_GAP = "  ";
+function paint(text, code) {
+  return code && text ? `${code}${text}${ANSI.reset}` : text;
+}
+function usageColor(percentage, danger = false) {
+  if (danger) return `${ANSI.red}${ANSI.bold}`;
+  if (typeof percentage !== "number" || !Number.isFinite(percentage)) return void 0;
+  if (percentage >= 85) return `${ANSI.red}${ANSI.bold}`;
+  if (percentage >= 60) return ANSI.yellow;
+  return ANSI.green;
+}
+function usageBar(percentage, options = {}) {
+  const width = options.width ?? BAR_WIDTH;
+  const known = typeof percentage === "number" && Number.isFinite(percentage);
+  const filled = known ? Math.max(0, Math.min(width, Math.round(percentage / 100 * width))) : 0;
+  const fill = known ? FILLED_CHAR.repeat(filled) : "";
+  const rest = known ? EMPTY_CHAR.repeat(width - filled) : UNKNOWN_CHAR.repeat(width);
+  if (!options.color) return `[${fill}${rest}]`;
+  return paint("[", ANSI.dim) + paint(fill, usageColor(percentage, options.danger)) + paint(rest, ANSI.dim) + paint("]", ANSI.dim);
 }
 function formatAmount(value, unit) {
   if (typeof value !== "number" || !Number.isFinite(value)) return "?";
@@ -1748,41 +1774,82 @@ function formatResetTime(expiresAt, now = Date.now()) {
   const relative = days > 0 ? `${days}d ${hours}h` : hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
   return `${new Date(timestamp).toISOString().slice(0, 10)} (in ${relative})`;
 }
-function formatBucketLine(label, bucket) {
-  const unit = bucket?.unit || "credits";
+function isBucketRow(row) {
+  return typeof row.used === "number" || typeof row.total === "number";
+}
+function rightCell(text, width, code) {
+  return " ".repeat(Math.max(0, width - text.length)) + paint(text, code);
+}
+function renderUsageRows(rows, notes, color) {
+  const buckets = rows.filter(isBucketRow);
+  const usedWidth = Math.max(0, ...buckets.map((row) => formatAmount(row.used).length));
+  const totalWidth = Math.max(0, ...buckets.map((row) => formatAmount(row.total).length));
+  const unitWidth = Math.max(0, ...buckets.map((row) => (row.unit ?? "").length));
+  const remainWidth = Math.max(0, ...buckets.map((row) => formatAmount(row.remaining).length));
+  const labelWidth = Math.max(0, ...rows.map((row) => row.label.length), ...notes.map((note) => note.label.length));
+  const percentWidth = Math.max(0, ...rows.map((row) => row.percent === void 0 ? 1 : `${row.percent}%`.length));
+  const amountWidth = buckets.length > 0 ? usedWidth + 3 + totalWidth + 1 + unitWidth : 0;
+  const remainder = (row) => isBucketRow(row) ? `${formatAmount(row.remaining).padStart(remainWidth)} left` : row.tail ?? "";
+  const remainderWidth = Math.max(0, ...rows.map((row) => remainder(row).length));
+  const lines = rows.map((row) => {
+    const amount = isBucketRow(row) ? `${formatAmount(row.used).padStart(usedWidth)} / ${formatAmount(row.total).padStart(totalWidth)} ${(row.unit ?? "").padEnd(unitWidth)}` : " ".repeat(amountWidth);
+    const percent = row.percent === void 0 ? UNKNOWN_CHAR : `${row.percent}%`;
+    return [
+      row.label.padEnd(labelWidth),
+      usageBar(row.percent, { color, danger: row.danger }),
+      amount,
+      rightCell(percent, percentWidth, color ? usageColor(row.percent, row.danger) : void 0),
+      remainder(row).padEnd(remainderWidth)
+    ].join(COLUMN_GAP);
+  });
+  for (const note of notes) {
+    lines.push(`${note.label.padEnd(labelWidth)}${COLUMN_GAP}${color ? paint(note.value, note.color) : note.value}`);
+  }
+  return lines.map((line) => line.replace(/ +$/, ""));
+}
+function bucketRow(label, bucket, danger) {
   const rawPercent = bucket?.percentage;
   const derivedPercent = typeof bucket?.used === "number" && typeof bucket?.total === "number" && bucket.total > 0 ? bucket.used / bucket.total * 100 : void 0;
   const percent = formatPercent(
     typeof rawPercent === "number" && Number.isFinite(rawPercent) ? rawPercent : derivedPercent
   );
-  const percentText = percent === void 0 ? "?" : `${percent}%`;
-  return `  ${usageBar(percent)} ${label}: ${formatAmount(bucket?.used, unit)} / ${formatAmount(
-    bucket?.total,
-    unit
-  )} used (${percentText}) \xB7 ${formatAmount(bucket?.remaining, unit)} left`;
+  return {
+    label,
+    percent,
+    used: bucket?.used,
+    total: bucket?.total,
+    remaining: bucket?.remaining,
+    unit: bucket?.unit || "credits",
+    danger
+  };
 }
 function hasBucket(bucket) {
   if (!bucket) return false;
   return (bucket.total ?? 0) > 0 || (bucket.used ?? 0) > 0;
 }
-function formatQoderUsage(raw, mode, now = Date.now()) {
+function formatQoderUsage(raw, mode, now = Date.now(), options = {}) {
+  const color = options.color ?? false;
   const region = getQoderRegionConfig(mode);
-  const lines = [];
+  const danger = Boolean(raw?.isQuotaExceeded);
   const userType = raw?.userType ? ` (${raw.userType})` : "";
   const overallPercent = formatPercent(raw?.totalUsagePercentage);
-  lines.push(`${region.usageTitle}${userType}`);
-  lines.push(`${usageBar(overallPercent)} ${overallPercent === void 0 ? "?" : `${overallPercent}%`} used`);
-  if (raw?.isQuotaExceeded) lines.push("  ! quota exceeded");
+  const rows = [{ label: "Overall", percent: overallPercent, tail: "used", danger }];
   const showUserQuota = hasBucket(raw?.userQuota);
   const showAddOnQuota = hasBucket(raw?.addOnQuota);
-  if (showUserQuota) lines.push(formatBucketLine("Plan quota", raw.userQuota));
-  if (showAddOnQuota) lines.push(formatBucketLine("Add-on quota", raw.addOnQuota));
-  if (!showUserQuota && !showAddOnQuota) lines.push("  No quota buckets returned.");
-  if (raw?.isPlanQuotaProrated) lines.push("  (plan quota is prorated)");
-  lines.push(`Resets: ${formatResetTime(raw?.expiresAt, now)}`);
+  if (showUserQuota) rows.push(bucketRow("Plan quota", raw.userQuota, danger));
+  if (showAddOnQuota) rows.push(bucketRow("Add-on", raw.addOnQuota, danger));
+  const notes = [];
+  if (danger) notes.push({ label: "Status", value: "quota exceeded", color: ANSI.red });
+  if (!showUserQuota && !showAddOnQuota) notes.push({ label: "Buckets", value: "none returned" });
+  if (raw?.isPlanQuotaProrated) notes.push({ label: "Note", value: "plan quota is prorated" });
+  notes.push({ label: "Resets", value: formatResetTime(raw?.expiresAt, now) });
   const manageUrl = raw?.addOnQuota?.detailUrl || raw?.upgradeUrl || region.manageUrl;
-  if (manageUrl) lines.push(`Manage: ${manageUrl}`);
-  return { title: region.usageTitle, lines };
+  if (manageUrl) notes.push({ label: "Manage", value: manageUrl });
+  const title = `${region.usageTitle}${userType}`;
+  return {
+    title: region.usageTitle,
+    lines: [paint(title, color ? ANSI.bold : void 0), ...renderUsageRows(rows, notes, color)]
+  };
 }
 async function fetchQoderQuota(accessToken, mode) {
   const response = await fetch(getQoderUsageURL(mode), {
@@ -1819,6 +1886,14 @@ async function resolveAccessToken(providerID, ctx) {
   return getCachedCredentials2("", providerID)?.access || void 0;
 }
 var FORMAT_ARGS = /* @__PURE__ */ new Set(["json", "raw", "debug"]);
+var PLAIN_ARGS = /* @__PURE__ */ new Set(["plain", "no-color", "nocolor"]);
+function shouldColorize(args, options = {}) {
+  if (PLAIN_ARGS.has((args || "").trim().toLowerCase())) return false;
+  const env = options.env ?? process.env;
+  if (env.NO_COLOR || env.TERM === "dumb" || env.FORCE_COLOR === "0") return false;
+  if (options.hasUI) return true;
+  return options.isTTY ?? Boolean(process.stdout?.isTTY);
+}
 async function runUsageCommand(mode, args, ctx) {
   const region = getQoderRegionConfig(mode);
   const providerID = region.providerID;
@@ -1830,7 +1905,8 @@ async function runUsageCommand(mode, args, ctx) {
       return;
     }
     const raw = await fetchQoderQuota(accessToken, mode);
-    const output = wantsRaw ? JSON.stringify(raw, null, 2) : formatQoderUsage(raw, mode).lines.join("\n");
+    const color = !wantsRaw && shouldColorize(args, { hasUI: Boolean(ctx?.ui) });
+    const output = wantsRaw ? JSON.stringify(raw, null, 2) : formatQoderUsage(raw, mode, Date.now(), { color }).lines.join("\n");
     ctx?.ui?.notify(output, "info");
     if (!ctx?.ui) console.log(output);
   } catch (error) {
@@ -1880,6 +1956,68 @@ function qoderEncodeBody(plaintext) {
   return out;
 }
 
+// src/protocol/queue.ts
+var MAX_QUEUE_RETRIES = 3;
+var MAX_WAIT_MS = 12e4;
+var DEFAULT_RETRY_SECONDS = 30;
+function digForQueue(node, depth) {
+  if (depth > 6) return null;
+  if (typeof node === "string") {
+    const trimmed = node.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+    try {
+      return digForQueue(JSON.parse(trimmed), depth + 1);
+    } catch {
+      return null;
+    }
+  }
+  if (node === null || typeof node !== "object") return null;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const found = digForQueue(item, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  const record = node;
+  if (record.isQueued === true) return record;
+  for (const value of Object.values(record)) {
+    const found = digForQueue(value, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function positiveNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function parseQueueNotice(envelope) {
+  const payload = digForQueue(envelope, 0);
+  if (!payload) return null;
+  return {
+    retryAfterMs: Math.min(positiveNumber(payload.retryAfterSeconds, DEFAULT_RETRY_SECONDS) * 1e3, MAX_WAIT_MS),
+    waitTimeSeconds: positiveNumber(payload.waitTime, 0),
+    queueCount: positiveNumber(payload.queueCount, 0)
+  };
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted while waiting for the Qoder queue."));
+      return;
+    }
+    let timer;
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("Aborted while waiting for the Qoder queue."));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // src/protocol/thinking.ts
 var THINKING_TAG_VARIANTS = [
   { open: "<thinking>", close: "</thinking>" },
@@ -2270,6 +2408,49 @@ function contentToText(content) {
   }
   return "";
 }
+var PeekableReader = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  pending = [];
+  text = "";
+  /** Read one chunk, replaying peeked bytes first.
+   */
+  async read() {
+    const buffered = this.pending.shift();
+    if (buffered) return { done: false, value: buffered };
+    return await this.inner.read();
+  }
+  /**
+   * Buffer chunks until the first complete line is available, and return the
+   * text seen so far. Every byte read here is replayed by later `read()` calls.
+   */
+  async peekLine(decoder) {
+    while (!this.text.includes("\n")) {
+      const { done, value } = await this.inner.read();
+      if (done) break;
+      this.pending.push(value);
+      this.text += decoder.decode(value, { stream: true });
+    }
+    return this.text;
+  }
+  cancel(reason) {
+    return this.inner.cancel(reason);
+  }
+};
+async function peekQueueNotice(reader, decoder) {
+  const text = await reader.peekLine(decoder);
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  if (!firstLine.startsWith("data:")) return null;
+  const payload = firstLine.slice(5).trim();
+  if (!payload || payload === "[DONE]") return null;
+  try {
+    return parseQueueNotice(JSON.parse(payload));
+  } catch {
+    return null;
+  }
+}
 function resolveRequestContext(piAi, context) {
   const {
     collapseSystemMessages,
@@ -2431,29 +2612,52 @@ function streamQoder(model, context, options) {
         machineID
       });
       const modelSource = modelConfig.source || "system";
-      const response = await fetch(chatURL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Accept-Encoding": "identity",
-          "X-Model-Key": qoderModel,
-          "X-Model-Source": modelSource,
-          ...headers
-        },
-        body: encodedBytes,
-        signal: options?.signal
-      });
-      if (!response.ok) {
-        const errText = await response.text();
-        throw new Error(`Qoder API request failed: ${response.status} ${response.statusText}. Response: ${errText}`);
-      }
-      const reader = response.body?.getReader();
-      if (!reader) throw new Error("No response body");
-      const decoder = new TextDecoder();
+      let queuedAttempt = 0;
+      let reader;
+      let decoder;
       let buffer = "";
       let bufferStart = 0;
+      for (; ; ) {
+        const response = await fetch(chatURL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Accept-Encoding": "identity",
+            "X-Model-Key": qoderModel,
+            "X-Model-Source": modelSource,
+            ...headers
+          },
+          body: encodedBytes,
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          const errText = await response.text();
+          throw new Error(`Qoder API request failed: ${response.status} ${response.statusText}. Response: ${errText}`);
+        }
+        const body = response.body;
+        if (!body) throw new Error("No response body");
+        reader = new PeekableReader(body.getReader());
+        decoder = new TextDecoder();
+        buffer = "";
+        bufferStart = 0;
+        const queue = await peekQueueNotice(reader, decoder);
+        if (queue) {
+          await reader.cancel().catch(() => {
+          });
+          if (queuedAttempt >= MAX_QUEUE_RETRIES) {
+            throw new Error(
+              `Qoder is at capacity: the request stayed queued after ${queuedAttempt + 1} attempts (~${queue.waitTimeSeconds}s wait reported). Try again shortly.`
+            );
+          }
+          queuedAttempt++;
+          await sleep(queue.retryAfterMs, options?.signal);
+          continue;
+        }
+        break;
+      }
+      if (!reader || !decoder) throw new Error("No response body");
       let contentBlockIndex = -1;
       let thinkingBlockIndex = -1;
       let rawReasoningTail = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-qoder-cn",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Pi extension for Qoder CN — PAT/OAuth auth, /qoder-cn.usage quota command, and enterprise VPC endpoint support",
   "type": "module",
   "license": "MIT",