@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/grok/billing.mjs

@@ -0,0 +1,146 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// dscode: what the Grok subscription left, and when it resets. The CLI proxy answers two
+// payloads on the same credential the models come from: /settings names the tier, and
+// /billing?format=credits carries the weekly window plus the used percentage. The
+// percentage is optional (the server omits it when a period has no usage), so the status
+// line has three states: a number, no usage recorded yet, and unreadable.
+//
+// This is the undocumented rail the official CLI itself reads; every field is optional and
+// a shape change must degrade to "usage unavailable", never to a crash or a wrong number.
+
+export const GROK_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+export const GROK_SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+/** The CLI re-reads its subscription every 60s (`subscription_watch_interval_secs`); so does DSCODE. */
+export const GROK_SUBSCRIPTION_TTL_MS = 60_000;
+const FILE = "grok-subscription.json";
+const VERSION = 1;
+let state;
+let fetchedAt = 0;
+let pending;
+let disk;
+
+const finite = value => Number.isFinite(Number(value)) ? Number(value) : undefined;
+const percent = value => {
+  const number = finite(value);
+  return number === undefined ? undefined : Math.min(100, Math.max(0, number));
+};
+const stamp = value => typeof value === "string" && value.length > 0 ? value : undefined;
+
+/**
+ * The weekly credit window from one `/billing?format=credits` body.
+ * @returns `{ usedPercent?, periodStart?, periodEnd?, periodType?, onDemandCap?, onDemandUsed?,
+ *   prepaidBalance?, unified? }` with unknown fields left out.
+ */
+export function parseGrokCredits(body) {
+  const config = body?.config ?? {};
+  const period = config.currentPeriod ?? {};
+  const used = percent(config.creditUsagePercent);
+  const onDemandCap = finite(config.onDemandCap?.val);
+  const onDemandUsed = finite(config.onDemandUsed?.val);
+  const prepaid = finite(config.prepaidBalance?.val);
+  const periodEnd = stamp(period.end) ?? stamp(config.billingPeriodEnd);
+  const periodStart = stamp(period.start) ?? stamp(config.billingPeriodStart);
+  return {
+    ...used === undefined ? {} : { usedPercent: used },
+    ...periodStart === undefined ? {} : { periodStart },
+    ...periodEnd === undefined ? {} : { periodEnd },
+    ...stamp(period.type) === undefined ? {} : { periodType: stamp(period.type) },
+    ...onDemandCap === undefined ? {} : { onDemandCap },
+    ...onDemandUsed === undefined ? {} : { onDemandUsed },
+    ...prepaid === undefined ? {} : { prepaidBalance: prepaid },
+    ...config.isUnifiedBillingUser === true ? { unified: true } : {},
+  };
+}
+
+/** The plan facts from one `/settings` body: the tier label and the access gate. */
+export function parseGrokSettings(body) {
+  const tier = stamp(body?.subscription_tier_display);
+  const gate = stamp(body?.gate_message);
+  const gateUrl = stamp(body?.gate_url);
+  return {
+    ...tier === undefined ? {} : { tier },
+    ...stamp(body?.default_model) === undefined ? {} : { defaultModel: stamp(body.default_model) },
+    ...body?.allow_access === false ? { blocked: true } : {},
+    ...gate === undefined ? {} : { gateMessage: gate },
+    ...gateUrl === undefined ? {} : { gateUrl },
+  };
+}
+
+/** Both reads at once; either half may fail without losing the other. */
+export async function fetchGrokSubscription({ token, userId, version = "1.0.34", fetch: fetchImpl = globalThis.fetch, now = Date.now() } = {}) {
+  if (typeof fetchImpl !== "function") return undefined;
+  const headers = { authorization: "Bearer " + token, accept: "application/json", "x-xai-token-auth": "xai-grok-cli", "x-authenticateresponse": "authenticate-response", "x-grok-client-version": version, ...userId === undefined ? {} : { "x-userid": userId } };
+  const read = async url => {
+    try {
+      const response = await fetchImpl(url, { headers });
+      return response.ok ? await response.json() : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  const [credits, settings] = await Promise.all([read(GROK_BILLING_URL), read(GROK_SETTINGS_URL)]);
+  if (credits === undefined && settings === undefined) return undefined;
+  return { ...parseGrokSettings(settings), ...parseGrokCredits(credits), fetchedAt: now };
+}
+
+/** The state the status line renders: cached for one refresh interval, one request in flight. */
+export async function currentGrokSubscription({ home, ...options } = {}) {
+  if (state !== undefined && Date.now() - fetchedAt < GROK_SUBSCRIPTION_TTL_MS) return state;
+  if (pending) return pending;
+  pending = (async () => {
+    const next = await fetchGrokSubscription(options);
+    if (next !== undefined) {
+      state = next;
+      fetchedAt = next.fetchedAt ?? Date.now();
+      if (home !== undefined) writeGrokSubscription(home, next);
+    }
+    return state;
+  })().finally(() => { pending = undefined; });
+  return pending;
+}
+
+/** The last written subscription state, or undefined before the first successful read. */
+export function readGrokSubscription(home) {
+  try {
+    const cached = JSON.parse(readFileSync(join(home, FILE), "utf8"));
+    return cached?.version === VERSION && typeof cached === "object" ? cached : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Atomic write of one state snapshot; a failure leaves the previous file alone. */
+export function writeGrokSubscription(home, snapshot) {
+  try {
+    mkdirSync(home, { recursive: true });
+    const path = join(home, FILE);
+    writeFileSync(path + ".tmp", JSON.stringify({ version: VERSION, ...snapshot }));
+    renameSync(path + ".tmp", path);
+  } catch { /* the status line simply keeps its previous state */ }
+}
+
+/** Replace the in-memory state; for tests. */
+export function setGrokSubscription(next, at = Date.now()) {
+  state = next;
+  fetchedAt = at;
+  pending = undefined;
+  disk = undefined;
+}
+
+/**
+ * The cached state without waiting for a fetch; the view uses this during a render. The live
+ * process wins, then the state file the panel already reads, so a footer drawn before the
+ * first refresh — or one drawn while the network is down — still shows the last window
+ * instead of falling back to a bare tier name. One file read per refresh window keeps the
+ * render path off the disk.
+ */
+export function grokSubscriptionNow(home = process.env.DSH_HOME) {
+  if (state !== undefined) return state;
+  if (home === undefined) return undefined;
+  if (disk !== undefined && disk.home === home && Date.now() - disk.at < GROK_SUBSCRIPTION_TTL_MS) return disk.value;
+  const value = readGrokSubscription(home);
+  disk = { home, at: Date.now(), value };
+  return value;
+}

package/plugins/grok/index.mjs

@@ -0,0 +1,122 @@
+import z from "@deepseek-ai/schemastery";
+import { RetryPolicySchema, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { deepEqualJson } from "@deepseek-ai/dsh-util-values";
+import { plainConfig } from "../cordis-config/plain.mjs";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { GrokAdapter, PROVIDER } from "./adapter.mjs";
+import { ensureGrokModels } from "./models.mjs";
+import { GROK_SUBSCRIPTION_TTL_MS, currentGrokSubscription } from "./billing.mjs";
+import { GROK_TOKEN_REF, grokAuthState } from "./auth.mjs";
+
+// dscode: the `grok` route — the SuperGrok / X Premium+ subscription the official grok CLI
+// already signed in for, driven through xAI chat completions. The token is read (never
+// written) from the CLI credential file, the catalog and the weekly credit window come from
+// the same CLI proxy the official client uses, and the status line reads the cached window
+// instead of a dollar balance: a subscription has credits, not a bill.
+export const name = "dscode-grok";
+export const inject = ["llm"];
+const NS = "llm-grok";
+const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+/** The client version the CLI proxy is asked with; xAI refuses requests without one. */
+const DEFAULT_CLIENT_VERSION = "1.0.34";
+
+// DSH 0.1.7 replaced settings sections with volatile configuration: each `.volatile()`
+// field arrives as a reference the Settings form and a profile edit both write, so the
+// reads below always see the current value.
+export const Config = z.object({
+  apiKeyEnv: z.string().role("credential-ref").default(GROK_TOKEN_REF).volatile(),
+  baseURL: z.string().default(DEFAULT_BASE_URL).volatile(),
+  clientVersion: z.string().default(DEFAULT_CLIENT_VERSION).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(300000).volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
+});
+
+
+/** Validated connection facts from one config snapshot. */
+export function resolveOptions(config = {}) {
+  const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 300000;
+  if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0) throw new Error(name + ": streamIdleTimeoutMs must be a positive number");
+  const baseURL = (config.baseURL || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  if (!URL.canParse(baseURL)) throw new Error(name + ": baseURL must be a URL");
+  return {
+    apiKeyEnv: credentialRef(config.apiKeyEnv || GROK_TOKEN_REF),
+    baseURL,
+    clientVersion: config.clientVersion || DEFAULT_CLIENT_VERSION,
+    streamIdleTimeoutMs,
+    retryPolicy: resolveRetryPolicy(config.retryPolicy, name + ": retryPolicy"),
+  };
+}
+
+/** The message a missing or expired CLI login deserves: the fix is a command, not a paste. */
+export function loginHint(state) {
+  if (state.kind === 'missing') return name + ': no local grok login found; run "grok login" (DSCODE reads ~/.grok/auth.json read-only)';
+  if (state.kind === 'expired') return name + ': the local grok login expired; run "grok login" again (DSCODE never rotates that token)';
+  return name + ': the local grok login file was not readable; run "grok login" again';
+}
+
+export function apply(ctx, config = {}) {
+  // The TUI renders this route's own page, so Settings must not generate a form for it.
+  ctx.inject(["settings"], settingsCtx => {
+    settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
+  });
+  let lastGood;
+  const options = () => {
+    try {
+      lastGood = resolveOptions(plainConfig(config));
+      return lastGood;
+    } catch (error) {
+      if (lastGood === undefined) throw error;
+      ctx.logger.error(name + ": keeping the last good configuration after an invalid edit");
+      return lastGood;
+    }
+  };
+  options();
+  const home = process.env.DSH_HOME;
+  /** The credential the route calls with, or undefined: the catalog must load without a login. */
+  const resolveTokenSafe = async () => {
+    const ref = options().apiKeyEnv;
+    const credentials = ctx.get("credentials");
+    try {
+      const stored = credentials === undefined ? launchEnvironmentOf(ctx).get(ref)?.value : (await credentials.resolve(ref))?.value;
+      if (stored !== undefined && stored.length > 0) return stored;
+    } catch { /* fall through to the local login state for a better message */ }
+    const state = grokAuthState();
+    return state.kind === "ready" ? state.credential.token : undefined;
+  };
+  const resolveToken = async () => {
+    const token = await resolveTokenSafe();
+    if (token !== undefined) return token;
+    throw new Error(loginHint(grokAuthState()));
+  };
+  const ensureModels = async () => {
+    const token = await resolveTokenSafe();
+    if (token === undefined) return;
+    await ensureGrokModels({ home, token, version: options().clientVersion });
+  };
+  const adapter = new GrokAdapter({ options, ensureModels, resolveToken });
+  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: "Grok", settingsNs: ctx.fiber.entry?.options.id ?? NS, settingsPath: [] }]);
+  const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
+  // The retry policy is captured at registration, and a reference carries no change
+  // callback: re-register the route when an edit lands on a different policy.
+  let registeredPolicy = options().retryPolicy;
+  ctx.on("loader/volatile-update", () => {
+    let policy;
+    try { policy = options().retryPolicy; } catch (error) { ctx.logger.warn(error); return; }
+    if (deepEqualJson(policy, registeredPolicy)) return;
+    registration.replace([PROVIDER]);
+    registeredPolicy = policy;
+  });
+  // Warm the catalog and the weekly window for a user who already ran `grok login`, then keep
+  // the window fresh at the interval the official CLI itself watches (subscription_watch_interval_secs).
+  const refresh = async () => {
+    const state = grokAuthState();
+    if (state.kind !== "ready") return;
+    await ensureGrokModels({ home, token: state.credential.token, version: options().clientVersion });
+    await currentGrokSubscription({ home, token: state.credential.token, userId: state.credential.userId, version: options().clientVersion });
+  };
+  void refresh().catch(() => {});
+  const timer = setInterval(() => { void refresh().catch(() => {}); }, GROK_SUBSCRIPTION_TTL_MS);
+  timer.unref?.();
+  ctx.effect(() => () => clearInterval(timer));
+}

package/plugins/grok/models.mjs

@@ -0,0 +1,129 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// dscode: the Grok model catalog. The subscription rail serves its models from the same
+// CLI proxy the official `grok` client uses, and that listing carries what a harness needs:
+// the context window, the reasoning detents (xhigh/high/medium/low, which are DSCODE effort
+// ids already), the backend-search flag and the compaction threshold. One table, kept for a
+// day in DSH_HOME, backs /model, compaction and the status line.
+
+export const GROK_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
+/** How long a first model lookup waits for the listing before answering without it. */
+export const GROK_MODELS_TIMEOUT_MS = 10_000;
+/** How long a failed listing (or an unusable cache file) waits before the next attempt. */
+export const GROK_MODELS_RETRY_MS = 10 * 60 * 1000;
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const FILE = "grok-models.json";
+const VERSION = 1;
+/** Reasoning detents DSCODE names; the wire spells them the same way through this route. */
+export const GROK_EFFORTS = Object.freeze(["low", "medium", "high", "xhigh"]);
+/** Media models the chat route must not offer to an agent. */
+const NON_CHAT = /(?:imagine|video|image|audio|vision-gen)/i;
+let table = { fetchedAt: 0, models: {} };
+let cacheReadAt = 0;
+let attemptedAt = 0, pending;
+
+const positive = value => Number.isSafeInteger(value) && value > 0 ? value : undefined;
+
+/**
+ * Models from one `/models` body of the Grok CLI proxy, or of the public api.x.ai listing.
+ * @returns `{ [id]: { name, description?, contextWindow?, maxOutput?, efforts?, defaultEffort?,
+ *   backendSearch?, compactThresholdPercent?, compactionAtTokens? } }`
+ */
+export function parseGrokModels(body) {
+  const models = {};
+  for (const model of Array.isArray(body?.data) ? body.data : []) {
+    const id = typeof model?.id === "string" ? model.id : typeof model?.model === "string" ? model.model : undefined;
+    if (id === undefined || id.length === 0 || NON_CHAT.test(id)) continue;
+    const efforts = (Array.isArray(model.reasoning_efforts) ? model.reasoning_efforts : [])
+      .map(entry => typeof entry === "string" ? entry : entry?.id)
+      .filter(level => GROK_EFFORTS.includes(level));
+    const named = efforts.length > 0 ? GROK_EFFORTS.filter(level => efforts.includes(level)) : undefined;
+    const defaultEffort = typeof model.reasoning_effort === "string" && GROK_EFFORTS.includes(model.reasoning_effort) ? model.reasoning_effort : undefined;
+    const contextWindow = positive(model.context_window) ?? positive(model.context_length);
+    models[id] = {
+      name: typeof model.name === "string" && model.name.length > 0 ? model.name : id,
+      ...typeof model.description === "string" && model.description.length > 0 ? { description: model.description } : {},
+      ...contextWindow === undefined ? {} : { contextWindow },
+      ...positive(model.max_completion_tokens) === undefined ? {} : { maxOutput: positive(model.max_completion_tokens) },
+      ...named === undefined ? {} : { efforts: named }, ...defaultEffort === undefined ? {} : { defaultEffort },
+      ...model.supports_backend_search === true ? { backendSearch: true } : {},
+      ...positive(model.auto_compact_threshold_percent) === undefined ? {} : { compactThresholdPercent: positive(model.auto_compact_threshold_percent) },
+      ...model.compaction_at_tokens === true ? { compactionAtTokens: true } : {},
+    };
+  }
+  return models;
+}
+
+/** One model entry, or undefined when the table does not list it. */
+export function grokModel(id) {
+  return Object.hasOwn(table.models, id) ? table.models[id] : undefined;
+}
+
+/** Every listed model as `[id, entry]` pairs, in listing order. */
+export function listGrokModels() {
+  return Object.entries(table.models);
+}
+
+/** Replace the table (and forget the last attempt); for tests and cache loads. */
+export function setGrokModels(models, fetchedAt = Date.now()) {
+  table = { fetchedAt, models };
+  cacheReadAt = 0;
+  attemptedAt = 0;
+}
+
+/** The headers the official CLI sends; the proxy answers a request without them with its generic API rail. */
+export function grokCliHeaders(token, version) {
+  return { authorization: "Bearer " + token, accept: "application/json", "x-xai-token-auth": "xai-grok-cli", "x-grok-client-version": version };
+}
+
+/**
+ * Load the cached table, then refetch it once it is a day old. A failure keeps the last
+ * table and waits ten minutes before trying again; never throws.
+ */
+export async function refreshGrokModels({ home, token, version = "1.0.34", fetch: fetchImpl = globalThis.fetch, now = Date.now() } = {}) {
+  const path = home ? join(home, FILE) : undefined;
+  if (table.fetchedAt === 0 && path && now - cacheReadAt >= GROK_MODELS_RETRY_MS) {
+    cacheReadAt = now;
+    try {
+      const cached = JSON.parse(readFileSync(path, "utf8"));
+      if (cached?.version === VERSION && Number.isFinite(cached.fetchedAt) && cached.models && typeof cached.models === "object") table = { fetchedAt: cached.fetchedAt, models: cached.models };
+    } catch { /* no usable cache */ }
+  }
+  if (now - table.fetchedAt < MAX_AGE_MS || now - attemptedAt < GROK_MODELS_RETRY_MS || token === undefined || typeof fetchImpl !== "function") return table;
+  if (pending) return pending;
+  attemptedAt = now;
+  pending = (async () => {
+    try {
+      const response = await fetchImpl(GROK_MODELS_URL, { headers: grokCliHeaders(token, version) });
+      if (!response.ok) return table;
+      const models = parseGrokModels(await response.json());
+      if (Object.keys(models).length === 0) return table;
+      table = { fetchedAt: now, models };
+      if (path) {
+        mkdirSync(home, { recursive: true });
+        writeFileSync(path + ".tmp", JSON.stringify({ version: VERSION, ...table }));
+        renameSync(path + ".tmp", path);
+      }
+      return table;
+    } catch {
+      return table;
+    } finally {
+      pending = undefined;
+    }
+  })();
+  return pending;
+}
+
+/**
+ * The table before a model lookup: an empty one waits up to `timeoutMs` for the listing,
+ * a stale one refreshes in the background.
+ */
+export async function ensureGrokModels({ timeoutMs = GROK_MODELS_TIMEOUT_MS, ...options } = {}) {
+  const refresh = refreshGrokModels(options);
+  if (Object.keys(table.models).length > 0) return table;
+  let timer;
+  await Promise.race([refresh, new Promise(resolve => { timer = setTimeout(resolve, timeoutMs); timer.unref?.(); })]);
+  clearTimeout(timer);
+  return table;
+}

package/plugins/grok/status.mjs

@@ -0,0 +1,28 @@
+import { grokAuthState, minutesLeft } from "./auth.mjs";
+import { grokSubscriptionNow, readGrokSubscription } from "./billing.mjs";
+
+// dscode: one snapshot for the two surfaces that show the Grok rail: the /login grok panel and
+// the provider list. The live process value wins; a state file written by another process (a
+// second DSCODE on the same Mac) is the fallback, so a panel opened before the first refresh
+// still shows the last known window.
+
+/**
+ * @returns `{ status: { kind, expiresIn? }, subscription? }`; `kind` is the local login state
+ *   (`ready`, `expired`, `missing`, `malformed`) and `expiresIn` is minutes on a ready login.
+ */
+export function grokStatusSnapshot({ home = process.env.DSH_HOME, now = Date.now() } = {}) {
+  const auth = grokAuthState({ now });
+  const stored = grokSubscriptionNow() ?? (home === undefined ? undefined : readGrokSubscription(home));
+  return {
+    status: { kind: auth.kind, ...auth.kind === "ready" ? { expiresIn: minutesLeft(auth.credential, now) } : {} },
+    ...stored === undefined ? {} : { subscription: stored },
+  };
+}
+
+/** One line for the provider list: the login state, not a key name. */
+export function grokStatusText(snapshot = grokStatusSnapshot()) {
+  if (snapshot.status.kind === "ready") return "grok login detected";
+  if (snapshot.status.kind === "expired") return "grok login expired · run grok login";
+  if (snapshot.status.kind === "malformed") return "grok login file unreadable · run grok login";
+  return "no grok login · run grok login";
+}