dsh-cliproxyapi-pro 1.6.0 → 1.7.0

package/lib/index.js

@@ -1,5 +1,7 @@
 // Zero-external-dependency host plugin for DSH CLIProxyAPI auto-discovery, model selection & sync.
-// Uses only Node.js built-ins and Cordis context services (`ctx.settings`, `ctx.credentials`, `ctx.commands`, `ctx.tools`, `ctx.webServer`).
+// Uses only Node.js built-ins and Cordis context services (`ctx.settings`, `ctx.credentials`, `ctx.commands`, `ctx.webServer`).
+// It deliberately registers no agent tool: accounts are managed in the Settings
+// page, HTTP routes and slash commands, so nothing adds to model context.
 
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -8,6 +10,7 @@ import {
   createPluginUpdater, loadUpdateSettings, saveUpdateSettings, storeUpdatePackage,
   UPDATE_INTERVAL_MS, UpdateError,
 } from "./updater.js";
+import { createQuotaController } from "./quota.js";
 
 // #region Constants & Config Resolution
 
@@ -372,7 +375,7 @@ export function newAccountDefaults(accounts) {
 }
 
 /**
- * Apply an account patch from the UI or the tool. `selectedModels` and
+ * Apply an account patch from the UI. `selectedModels` and
  * `modelOverrides` replace the stored value when present; the id never changes.
  */
 export function patchAccount(account, patch) {
@@ -905,7 +908,7 @@ export function buildPiAiRoutes(config, discovery, hasApiKey) {
   });
   if (filtered.length === 0) {
     throw new Error(
-      `dsh-cliproxyapi: none of the selected models matched the ${discovery.models.length} model(s) offered by ${discovery.rootURL}. Select models in Settings → Built-in plugins → CLIProxyAPI or with the cliproxyapi tool.`
+      `dsh-cliproxyapi: none of the selected models matched the ${discovery.models.length} model(s) offered by ${discovery.rootURL}. Select models in Settings → CLIProxyAPI → Models.`
     );
   }
   const auth = hasApiKey
@@ -1589,6 +1592,34 @@ export function createCpaController(deps) {
       return statusPayload({ removedId: account.id });
     },
 
+    /**
+     * Probe a CPA address with unsaved form values, without saving or writing
+     * routes. A blank `apiKey` uses the account's stored key; a blank
+     * `baseURL` follows the usual fallbacks. Never returns the key.
+     */
+    async testConnection(ref, input = {}) {
+      const state = deps.readState();
+      const account = ref === undefined || ref === null || String(ref).trim() === "" ? undefined : findAccount(state, ref);
+      const config = account === undefined ? undefined : accountConfig(state, account.id);
+      const draftKey = typeof input.apiKey === "string" ? input.apiKey.trim() : "";
+      const apiKey = draftKey !== "" ? draftKey : config === undefined ? undefined : await deps.resolveApiKey(effectiveKeyEnv(config));
+      const baseURL = typeof input.baseURL === "string" ? input.baseURL.trim() : "";
+      try {
+        const result = await discoverCpa({
+          baseURL,
+          autoDiscover: baseURL === "",
+          fallbackBaseURL: config === undefined ? undefined : deps.readExistingPiAiRoute?.(config.provider)?.baseURL,
+          environmentBaseURL: deps.environmentBaseURL?.(),
+          apiKey,
+          timeoutMs: state.probeTimeoutMs,
+          ...(deps.fetch === undefined ? {} : { fetch: deps.fetch }),
+        });
+        return { ok: true, test: { ok: true, endpoint: result.rootURL, modelCount: result.models.length } };
+      } catch (error) {
+        return { ok: true, test: { ok: false, error: error instanceof Error ? error.message : String(error) } };
+      }
+    },
+
     /** Accounts whose credential reference is `ref`. */
     accountsUsingKey(ref) {
       const state = deps.readState();
@@ -1600,6 +1631,38 @@ export function createCpaController(deps) {
 
     refreshAccount,
 
+    /**
+     * Account facts the quota engine needs: the CPA address it talks to and
+     * the DSH route keys whose models belong to this account. A conflicting
+     * account owns no routes, so none of its models map to quota.
+     */
+    quotaAccounts() {
+      const state = deps.readState();
+      const conflicts = accountConflicts(state.accounts);
+      return state.accounts.map((account) => {
+        const config = accountConfig(state, account.id);
+        const runtime = runtimes.get(account.id);
+        const st = runtime?.currentStatus ?? {};
+        const existingRoute = deps.readExistingPiAiRoute?.(config.provider);
+        const owners = new Map((runtime?.allDiscoveredModels ?? []).map((m) => [m.id, m.ownedBy]));
+        return {
+          id: account.id,
+          displayName: config.displayName,
+          provider: config.provider,
+          enabled: config.enabled === true,
+          baseURL: config.baseURL || "",
+          endpoint: st.endpoint || existingRoute?.baseURL || "",
+          routes: conflicts.has(account.id) ? [] : managedRouteKeys(config.provider),
+          // Models this account currently puts in the DSH picker.
+          pickerModels: (runtime?.syncedModels ?? []).map((m) => ({
+            id: m.id,
+            route: m.route,
+            ...(typeof owners.get(m.id) === "string" ? { ownedBy: owners.get(m.id) } : {}),
+          })),
+        };
+      });
+    },
+
     dispose() {
       for (const runtime of runtimes.values()) runtime.dispose();
       runtimes.clear();
@@ -1617,10 +1680,14 @@ export const ROUTES = {
   save: "/api/dsh-cliproxyapi/save",
   addAccount: "/api/dsh-cliproxyapi/accounts/add",
   removeAccount: "/api/dsh-cliproxyapi/accounts/remove",
+  testAccount: "/api/dsh-cliproxyapi/accounts/test",
   updateStatus: "/api/dsh-cliproxyapi/updates/status",
   updateCheck: "/api/dsh-cliproxyapi/updates/check",
   updateSave: "/api/dsh-cliproxyapi/updates/save",
   updateDownload: "/api/dsh-cliproxyapi/updates/download",
+  quotaStatus: "/api/dsh-cliproxyapi/quota/status",
+  quotaRefresh: "/api/dsh-cliproxyapi/quota/refresh",
+  quotaSave: "/api/dsh-cliproxyapi/quota/save",
 };
 
 function sendJson(res, status, payload) {
@@ -1861,10 +1928,37 @@ function renderAccountStatus(account) {
   return lines.join("\n");
 }
 
+/** One line per account: management key, quota state and what the picker models map to. Never includes keys. */
+export function renderQuotaText(snapshot, onlyAccountId) {
+  const accounts = (snapshot?.accounts ?? []).filter((a) => onlyAccountId === undefined || a.accountId === onlyAccountId);
+  if (accounts.length === 0) return "";
+  const lines = ["Quota (CPA management API):"];
+  for (const a of accounts) {
+    if (!a.keyConfigured) {
+      lines.push(`- ${a.displayName} [${a.accountId}]: no management key (${a.keyRef})`);
+      continue;
+    }
+    const creds = Array.isArray(a.credentials) ? a.credentials : [];
+    const state = a.state + (a.errorCode ? ` (${a.errorCode}${a.errorStatus ? ` ${a.errorStatus}` : ""})` : "") + (a.refreshing ? ", refreshing" : "");
+    lines.push(`- ${a.displayName} [${a.accountId}]: ${state}; ${creds.length} credential(s)${a.fetchedAt ? `; fetched ${a.fetchedAt}` : ""}; routes ${(a.routes ?? []).join(", ") || "none"}`);
+    for (const m of a.pickerModels ?? []) {
+      const ids = a.modelIndex?.[m.id] ?? [];
+      const names = ids.map((id) => {
+        const c = creds.find((x) => x.id === id);
+        if (!c) return id;
+        const pct = (c.windows ?? []).map((w) => w.remainingPercent).filter((v) => typeof v === "number");
+        return `${c.provider}:${c.label || c.id}${pct.length ? ` ${Math.round(Math.min(...pct))}%` : ""}${c.status === "active" ? "" : ` (${c.status})`}`;
+      });
+      lines.push(`    ${m.route}/${m.id} -> ${names.length ? names.join(", ") : "no credential"} [${a.modelMatch?.[m.id] ?? "none"}]`);
+    }
+  }
+  return lines.join("\n");
+}
+
 export function renderStatusText(payload, onlyAccountId) {
   const accounts = payload.accounts ?? [];
   if (accounts.length === 0) {
-    return "No CLIProxyAPI account is configured. Add one with the cliproxyapi tool (action 'add_account') or in Settings → Built-in plugins → CLIProxyAPI.";
+    return "No CLIProxyAPI account is configured. Add one in Settings → CLIProxyAPI.";
   }
   const shown =
     onlyAccountId === undefined ? accounts : accounts.filter((a) => a.id === onlyAccountId);
@@ -1873,22 +1967,7 @@ export function renderStatusText(payload, onlyAccountId) {
   return [header, ...shown.map(renderAccountStatus)].join("\n\n");
 }
 
-function summarizeAccount(account) {
-  const st = account.status;
-  return {
-    id: account.id,
-    displayName: account.config.displayName,
-    provider: account.config.provider,
-    enabled: account.config.enabled,
-    state: st.state,
-    ...(st.endpoint ? { endpoint: st.endpoint } : {}),
-    modelCount: st.modelCount ?? 0,
-    totalDiscovered: st.totalDiscovered ?? 0,
-    ...(st.error ? { error: st.error } : {}),
-  };
-}
-
-/** Account fields the tool and the save route accept, besides key handling. */
+/** Account fields the save and add routes accept, besides key handling. */
 function accountPatchFromInput(input) {
   const patch = {};
   for (const field of ["baseURL", "provider", "displayName", "protocol", "protocolMode", "includePrefix", "excludePrefix", "apiKeyEnv"]) {
@@ -2003,6 +2082,7 @@ function applyImpl(ctx, config) {
     writeSettings: (preferences) => saveUpdateSettings(updateSettingsPath, preferences),
     storePackage: (version, bytes) => storeUpdatePackage(join(updateDirectory, "updates"), version, bytes),
     onSettingsChanged: scheduleUpdates,
+    logger: ctx.logger,
   });
   ctx.effect(() => {
     scheduleUpdates(updater.status());
@@ -2079,6 +2159,26 @@ function applyImpl(ctx, config) {
     onGlobalsChanged: () => reschedule(),
   });
 
+  // Quota ("额度" tab + composer badge): management keys live in the
+  // credentials service under their own refs, never in account state.
+  const quota = createQuotaController({
+    listAccounts: () => controller.quotaAccounts(),
+    resolveKey: (ref) => resolveApiKey(ref),
+    describeKey: (ref) => describeApiKey(ref),
+    setKey: async (ref, value) => {
+      const credentials = ctx.get("credentials");
+      if (credentials === undefined) {
+        throw new Error("Credentials service is not available on this host");
+      }
+      await credentials.set(ref, value);
+    },
+    unsetKey: async (ref) => {
+      await ctx.get("credentials")?.unset(ref);
+    },
+    logger: ctx.logger,
+  });
+  ctx.effect(() => () => quota.dispose(), "cpa: quota");
+
   reschedule();
   startupTimeout = outsideHmrTransaction(ctx, () =>
     setTimeout(() => {
@@ -2110,7 +2210,8 @@ function applyImpl(ctx, config) {
         description: "Show CLIProxyAPI discovery and model synchronization status of every account.",
         handler: async () => {
           const payload = await controller.statusPayload();
-          return { kind: "success", text: renderStatusText(payload) };
+          const quotaText = renderQuotaText(await quota.snapshot());
+          return { kind: "success", text: [renderStatusText(payload), quotaText].filter(Boolean).join("\n\n") };
         },
       });
       const offRefresh = cmdCtx.commands.register({
@@ -2129,158 +2230,6 @@ function applyImpl(ctx, config) {
     }, "cpa: commands");
   });
 
-  // Register Agent Tool (cliproxyapi) directly via ctx.tools.register
-  ctx.inject(["tools"], (toolCtx) => {
-    toolCtx.effect(() => {
-      return toolCtx.tools.register({
-        name: "cliproxyapi",
-        description:
-          "Inspect, refresh, or configure CLIProxyAPI accounts (each one a CPA server + API key synchronized into its own DSH provider routes), add or remove accounts, enable or disable them, and filter which models each one shows in the DSH model selector.",
-        parameters: {
-          type: "object",
-          additionalProperties: false,
-          required: ["action"],
-          properties: {
-            action: {
-              type: "string",
-              enum: ["status", "refresh", "configure", "add_account", "remove_account"],
-              description:
-                "'status' reads every account (or only `account`), 'refresh' probes and syncs now, 'configure' updates one account, 'add_account' creates an account from the other fields, 'remove_account' deletes `account` and its model routes.",
-            },
-            account: {
-              type: "string",
-              description:
-                "Target account id (or its provider route ID / display name) for status, refresh, configure and remove_account. Defaults to the first account; refresh without it refreshes all.",
-            },
-            enabled: {
-              type: "boolean",
-              description:
-                "Enable or disable the account. A disabled account keeps its settings but its models leave the picker. add_account defaults to enabled when baseURL is given.",
-            },
-            baseURL: {
-              type: "string",
-              description:
-                "CLIProxyAPI base URL (e.g. http://127.0.0.1:8317). Empty means auto-discover locally.",
-            },
-            provider: {
-              type: "string",
-              description:
-                "Provider route ID in llm-pi-ai; must be unique per account (default: cli-proxy, then cli-proxy-2, ...).",
-            },
-            displayName: {
-              type: "string",
-              description: "Account name shown in the DSH model picker.",
-            },
-            protocolMode: {
-              type: "string",
-              enum: ["auto", "fixed"],
-              description:
-                "'auto' (default) sends each model over its own family's protocol: Claude via Anthropic Messages, GPT/Codex/Grok via OpenAI Responses, others (incl. Gemini) via OpenAI Chat. 'fixed' sends every model over `protocol`.",
-            },
-            protocol: {
-              type: "string",
-              enum: ["openai-completions", "openai-responses", "anthropic-messages"],
-              description: "Wire protocol used for every model when protocolMode is 'fixed'.",
-            },
-            selectedModels: {
-              type: "array",
-              items: { type: "string" },
-              description:
-                "Exact model IDs to show in the DSH model picker. Pass an empty array [] to show all discovered models.",
-            },
-            includePrefix: {
-              type: "string",
-              description: "Comma-separated model ID substrings/prefixes to include.",
-            },
-            excludePrefix: {
-              type: "string",
-              description: "Comma-separated model ID substrings/prefixes to exclude.",
-            },
-            apiKey: {
-              type: "string",
-              description:
-                "CLIProxyAPI Bearer key, stored in the DSH credentials service under the account's apiKeyEnv.",
-            },
-            apiKeyEnv: {
-              type: "string",
-              description:
-                "Credential reference name holding the account's key (default: CLI_PROXY_API_KEY, then CLI_PROXY_API_KEY_2, ...).",
-            },
-            modelOverrides: {
-              type: "object",
-              description:
-                "Per-model overrides keyed by model ID, replacing the account's whole map: { [modelId]: { contextWindow?: number, maxTokens?: number, image?: boolean, reasoningLevels?: string[], protocol?: 'openai-completions' | 'openai-responses' | 'anthropic-messages' } }.",
-            },
-          },
-        },
-        output: {
-          schema: {
-            type: "object",
-            additionalProperties: false,
-            required: ["accounts", "summary"],
-            properties: {
-              account: { type: "string" },
-              accounts: {
-                type: "array",
-                items: {
-                  type: "object",
-                  additionalProperties: false,
-                  required: ["id", "displayName", "provider", "enabled", "state", "modelCount", "totalDiscovered"],
-                  properties: {
-                    id: { type: "string" },
-                    displayName: { type: "string" },
-                    provider: { type: "string" },
-                    enabled: { type: "boolean" },
-                    state: { type: "string" },
-                    endpoint: { type: "string" },
-                    modelCount: { type: "integer" },
-                    totalDiscovered: { type: "integer" },
-                    error: { type: "string" },
-                  },
-                },
-              },
-              summary: { type: "string" },
-            },
-          },
-          render: (_args, value) => [{ type: "text", text: value.summary }],
-        },
-        async execute(args) {
-          const input = args ?? {};
-          const ref = typeof input.account === "string" && input.account.trim() !== "" ? input.account.trim() : undefined;
-          let target;
-          if (input.action === "refresh") {
-            target = (await controller.refresh(ref)).account;
-          } else if (input.action === "configure") {
-            target = (await controller.updateAccount(ref, accountPatchFromInput(input))).account;
-          } else if (input.action === "add_account") {
-            const patch = accountPatchFromInput(input);
-            if (patch.enabled === undefined) {
-              patch.enabled = typeof patch.baseURL === "string" && patch.baseURL.trim() !== "";
-            }
-            target = (await controller.addAccount(patch)).createdId;
-          } else if (input.action === "remove_account") {
-            if (ref === undefined) throw new Error("remove_account needs `account`");
-            await controller.removeAccount(ref);
-          } else if (ref !== undefined) {
-            target = controller.findAccount(ref).id;
-          }
-          const payload = await controller.statusPayload();
-          return {
-            ...(target === undefined ? {} : { account: target }),
-            accounts: payload.accounts.map(summarizeAccount),
-            summary: renderStatusText(payload, input.action === "status" ? target : undefined),
-          };
-        },
-        presentCall: (args) => ({
-          card: "generic",
-          title: `CLIProxyAPI: ${args?.action ?? "status"}${args?.account ? ` (${args.account})` : ""}`,
-          kind: args?.action === "status" ? "read" : "execute",
-          rawInput: args,
-        }),
-      });
-    }, "cpa: tool");
-  });
-
   // Register HTTP API Routes on webServer for the Web UI
   ctx.inject(["webServer"], (webCtx) => {
     webCtx.effect(() => {
@@ -2341,6 +2290,30 @@ function applyImpl(ctx, config) {
         ),
         route(ROUTES.addAccount, "POST", (body) => controller.addAccount(accountPatchFromInput(body)), 400),
         route(ROUTES.removeAccount, "POST", (body) => controller.removeAccount(body.accountId), 400),
+        route(ROUTES.testAccount, "POST", (body) => controller.testConnection(body.accountId, { baseURL: body.baseURL, apiKey: body.apiKey }), 400),
+        route(ROUTES.quotaStatus, "GET", async () => ({ ok: true, quota: await quota.snapshot() })),
+        route(ROUTES.quotaRefresh, "POST", async (body) => ({
+          ok: true,
+          quota: await quota.refresh(typeof body.accountId === "string" && body.accountId !== "" ? body.accountId : undefined, { wait: false }),
+        })),
+        route(
+          ROUTES.quotaSave,
+          "POST",
+          async (body) => {
+            if (typeof body.accountId !== "string" || body.accountId === "") {
+              throw new Error("dsh-cliproxyapi: saving a management key needs accountId");
+            }
+            const managementKey = typeof body.managementKey === "string" ? body.managementKey.trim() : "";
+            return {
+              ok: true,
+              quota: await quota.saveKey(body.accountId, {
+                ...(managementKey === "" ? {} : { managementKey }),
+                ...(body.clear === true ? { clear: true } : {}),
+              }, { wait: false }),
+            };
+          },
+          400
+        ),
       ];
       return () => {
         for (const dispose of disposers) dispose?.();