pi-provider-qoder-cn 0.2.1 → 0.2.3

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.
 
@@ -123,11 +138,39 @@ at startup is:
 
 1. `QODER_VPC_ENDPOINT` / `QODERCN_VPC_ENDPOINT`
 2. `~/.pi/agent/qoder-cn-settings.json`
-3. `~/.pi/agent/auth.json` (the `qoder-cn` entry)
-4. `~/.qoder-cn/settings.json` (the Qoder IDE's own file)
+
+Only these two count as chosen by you. This extension deliberately ignores
+endpoint values written by other Qoder clients — pi is one client among several,
+and another client's endpoint must not silently redirect pi's traffic.
 
 > The token and the endpoint must belong to the same instance. Pointing an
-> enterprise endpoint at a public-gateway token fails authentication.
+> enterprise endpoint at a public-gateway token fails authentication, which is
+> why `/login` settles the endpoint before it asks for the PAT.
+
+### Endpoint choice during `/login`
+
+`/login qoder-cn` asks which endpoint to use **before** prompting for the PAT,
+because the enterprise gateway also serves the token exchange. The list shows
+the currently saved endpoint and defaults to the personal account:
+
+```text
+Choose the Qoder CN endpoint (default: personal account)
+  → Personal account — public gateway (qoder.com.cn)
+    Enterprise account — use a VPC endpoint
+    Enterprise account — <detected value> (detected: stored credential)
+```
+
+- **Personal account** uses the public gateway and pins that choice, so a value
+  left behind by another client cannot resurface. If `QODER_VPC_ENDPOINT` /
+  `QODERCN_VPC_ENDPOINT` is set, it still wins — `/login` says so and warns
+  that a personal pick reverts on restart until the variable is removed.
+- **Enterprise account** then prompts for the instance name or domain.
+- Switching back and forth is expected; re-running `/login` presents the saved
+  endpoint so you can change it.
+
+A `vpc_endpoint` found in `~/.pi/agent/auth.json` is offered as the third option
+but never applied on its own. `/qoder-endpoint` with no argument also reports it
+under “Detected (not applied)”.
 
 ## Models
 

package/dist/index.js

@@ -268,21 +268,14 @@ function readVpcEndpointFromAuth() {
   }
   return void 0;
 }
-function readVpcEndpointFromQoderIde() {
-  try {
-    const path = join2(getHomeDir2(), ".qoder-cn", "settings.json");
-    if (!existsSync2(path)) return void 0;
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    const value = parsed?.vpc_endpoint ?? parsed?.vpcEndpoint ?? parsed?.vpcInstanceName;
-    if (value !== void 0 && value !== "") return String(value);
-  } catch {
-  }
-  return void 0;
+function readInheritedVpcEndpoint() {
+  const value = readVpcEndpointFromAuth();
+  return value ? { value, source: "stored credential" } : void 0;
 }
 function readQoderVpcEndpoint() {
   const fromEnv = process.env.QODER_VPC_ENDPOINT || process.env.QODERCN_VPC_ENDPOINT;
   if (fromEnv) return fromEnv;
-  return readVpcEndpointFromSettings() ?? readVpcEndpointFromAuth() ?? readVpcEndpointFromQoderIde() ?? "";
+  return readVpcEndpointFromSettings() ?? "";
 }
 function isResetValue(value) {
   const lowered = value.toLowerCase();
@@ -1217,6 +1210,15 @@ import crypto2 from "node:crypto";
 function getPrompt(callbacks) {
   return callbacks.onPrompt;
 }
+function getSelect(callbacks) {
+  const fn = callbacks.onSelect;
+  return typeof fn === "function" ? fn : void 0;
+}
+function isLoginCancellation(error, callbacks) {
+  if (getSignal(callbacks)?.aborted) return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes("cancel");
+}
 function getProgress(callbacks) {
   return callbacks.onProgress;
 }
@@ -1240,8 +1242,90 @@ function parseExpiresAt(s, expiresInSeconds) {
   }
   return Date.now() + 30 * 24 * 60 * 60 * 1e3;
 }
+async function confirmCnEndpoint(callbacks, mode) {
+  if (mode !== "cn") return;
+  const current = getQoderCNEndpoints();
+  const inherited = readInheritedVpcEndpoint();
+  const envNames = ["QODER_VPC_ENDPOINT", "QODERCN_VPC_ENDPOINT"].filter((name) => process.env[name]);
+  const personalId = "personal";
+  const enterpriseId = "enterprise";
+  const inheritedId = "enterprise-inherited";
+  const options = [
+    { id: personalId, label: "Personal account \u2014 public gateway (qoder.com.cn)" },
+    { id: enterpriseId, label: "Enterprise account \u2014 use a VPC endpoint" }
+  ];
+  if (inherited) {
+    options.push({
+      id: inheritedId,
+      label: `Enterprise account \u2014 ${inherited.value} (detected: ${inherited.source})`
+    });
+  }
+  let message = current.isDefault ? "Choose the Qoder CN endpoint to log in against (default: personal account)" : `Choose the Qoder CN endpoint to log in against (current: ${current.raw})`;
+  if (envNames.length > 0) {
+    message += `
+(current value comes from ${envNames.join(" / ")}; it still wins after a restart)`;
+  }
+  const choice = await askEndpointChoice(callbacks, message, options);
+  if (choice === personalId) {
+    setQoderCNEndpoint("");
+    if (envNames.length > 0) {
+      getProgress(callbacks)?.(
+        `Personal gateway selected. However, ${envNames.join(" / ")} takes precedence and restores the enterprise endpoint after a restart; remove the variable, then log in again.`
+      );
+    }
+    return;
+  }
+  if (choice === inheritedId && inherited) {
+    setQoderCNEndpoint(inherited.value);
+    return;
+  }
+  if (choice === enterpriseId) {
+    const prompt = getPrompt(callbacks);
+    const raw = await prompt({
+      message: "Enterprise VPC endpoint (instance name or domain)",
+      placeholder: "acme",
+      allowEmpty: true
+    });
+    if (getSignal(callbacks)?.aborted) throw new Error("Login cancelled");
+    const value = raw?.trim();
+    if (!value) return;
+    setQoderCNEndpoint(value);
+    return;
+  }
+}
+async function askEndpointChoice(callbacks, message, options) {
+  const select = getSelect(callbacks);
+  if (select) {
+    try {
+      const picked = await select({ message, options });
+      if (picked) return picked;
+      return void 0;
+    } catch (error) {
+      if (isLoginCancellation(error, callbacks)) throw error;
+    }
+  }
+  const prompt = getPrompt(callbacks);
+  const lines = options.map((option, index) => `${index + 1}. ${option.label}`);
+  const raw = await prompt({
+    message: `${message}
+${lines.join("\n")}
+Enter a number (Enter = 1, personal account)`,
+    placeholder: "1",
+    allowEmpty: true
+  });
+  if (getSignal(callbacks)?.aborted) throw new Error("Login cancelled");
+  const trimmed = raw?.trim();
+  if (!trimmed) return options[0]?.id;
+  const byIndex = Number.parseInt(trimmed, 10);
+  if (!Number.isNaN(byIndex) && byIndex >= 1 && byIndex <= options.length) {
+    return options[byIndex - 1]?.id;
+  }
+  const byId = options.find((option) => option.id === trimmed || option.label === trimmed);
+  return byId?.id ?? options[0]?.id;
+}
 async function interactiveLogin(callbacks, mode) {
   const region = getQoderRegionConfig(mode);
+  await confirmCnEndpoint(callbacks, mode);
   const prompt = getPrompt(callbacks);
   const pat = await prompt({
     message: !region.supportsBrowserLogin ? "Paste a Qoder CN Personal Access Token, or leave empty to cancel" : "Paste a Qoder Personal Access Token (pt-...), or leave empty for browser login",
@@ -1377,6 +1461,7 @@ var init_login = __esm({
     "use strict";
     init_cosy();
     init_region();
+    init_vpc();
     init_pat();
   }
 });
@@ -1685,10 +1770,13 @@ function describeEndpoint() {
 async function runEndpointCommand(args, ctx) {
   const input = (args || "").trim();
   if (!input) {
+    const inherited = readInheritedVpcEndpoint();
+    const inheritedHint = inherited ? `
+Detected (not applied): ${inherited.value} from ${inherited.source} \u2014 run /qoder-endpoint ${inherited.value} to use it.` : "";
     ctx?.ui?.notify(
       `Current Qoder CN endpoint: ${describeEndpoint()}
 To set: /qoder-endpoint <domain>
-To reset: /qoder-endpoint default`,
+To reset: /qoder-endpoint default${inheritedHint}`,
       "info"
     );
     return;
@@ -1719,11 +1807,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 +1862,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 +1974,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 +1993,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) {

package/package.json

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