@toddzheng024/dscode-bundle 0.7.27 → 0.7.29

package/plugins/account/index.mjs

@@ -0,0 +1,178 @@
+/**
+ * `/account`: the DeepSeek account login, from the terminal.
+ *
+ * DSH 0.1.7 added an account plane beside API keys: `deepseekAccount` signs in through the
+ * system browser with PKCE, keeps the grant in the local credential store, and the DeepSeek
+ * route resolves it for the configured inference origin — so a signed-in user needs no
+ * `DEEPSEEK_API_KEY` at all. Upstream drives that plane from its Web settings page; this
+ * command is DSCODE's terminal equivalent.
+ *
+ * The provider registers `/oauth/callback` on the Host webserver for the lifetime of one
+ * attempt, which is why the TUI profile composes a loopback webserver (see
+ * `packages/tui/cordis.patch.yml`). Without it the command says so instead of starting an
+ * attempt the browser could never complete.
+ *
+ * Tokens never pass through here: the service's view is the client-safe projection, and
+ * `resolveToken` stays Host-only inside the LLM route.
+ *
+ * @module dscode-account
+ */
+
+import { execFile } from 'node:child_process';
+import { readLanguage, t } from '../i18n/messages.mjs';
+import { ACTIVE_PHASES, TERMINAL_PHASES, callbackOrigin, outcomeLines, signInBlocked, statusLines } from './state.mjs';
+
+export const name = 'dscode-account';
+export const inject = ['commands'];
+
+/** Upper bound for one terminal-driven attempt; the provider applies its own deadline too. */
+const ATTEMPT_WAIT_MS = 300000;
+
+const ok = text => ({ kind: 'success', text });
+const fail = text => ({ kind: 'error', text });
+
+/** Open a URL in the user's browser, reporting failure instead of throwing. */
+export function openBrowser(url, { platform = process.platform, run = execFile } = {}) {
+  return new Promise(resolve => {
+    if (platform === 'win32') { resolve(false); return; }
+    run(platform === 'darwin' ? 'open' : 'xdg-open', [url], { timeout: 10000 }, error => resolve(!error));
+  });
+}
+
+/**
+ * Follow one attempt until `done(view)` accepts it, the attempt is replaced, or the wait
+ * runs out.
+ *
+ * `watch()` yields the current state first and then on every change, so an already
+ * settled attempt returns immediately and a cancelled one does not hang. Both the
+ * caller's signal and the bounded wait end the iteration.
+ *
+ * @param account - the account service.
+ * @param id - the attempt this wait belongs to; a different attempt ends the wait.
+ * @param done - predicate over each view; true stops the wait.
+ * @param signal - the command's cancellation.
+ * @returns the last view seen.
+ */
+export async function followAttempt(account, id, done, signal, { timeoutMs = ATTEMPT_WAIT_MS } = {}) {
+  const deadline = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+  let last = await account.getState();
+  if (done(last)) return last;
+  try {
+    for await (const view of account.watch(deadline)) {
+      last = view;
+      const attempt = view.attempt;
+      if (attempt === null || attempt.id !== id) break;
+      if (done(view)) break;
+    }
+  } catch { /* an aborted watch leaves the last view in place */ }
+  return last;
+}
+
+/** A view whose attempt carries the browser URL, or has already settled without one. */
+export function authorizeReady(view, id) {
+  const attempt = view.attempt;
+  if (attempt === null || attempt.id !== id) return true;
+  return attempt.authorizeUrl !== undefined || TERMINAL_PHASES.includes(attempt.phase);
+}
+
+/** A view whose attempt will not change again. */
+export function settled(view, id) {
+  const attempt = view.attempt;
+  if (attempt === null || attempt.id !== id) return true;
+  return TERMINAL_PHASES.includes(attempt.phase);
+}
+
+/**
+ * Run one browser sign-in to settlement.
+ *
+ * Kept apart from the command so the whole flow — waiting for the URL, opening the
+ * browser, following the attempt, reading the result — is drivable with a fake service
+ * and a fake opener.
+ *
+ * @param service - the account service.
+ * @param origin - the loopback callback origin.
+ * @param locale - DSCODE interface language.
+ * @param signal - the command's cancellation.
+ * @param open - browser opener returning whether it launched.
+ * @returns the lines to print and whether the sign-in succeeded.
+ */
+export async function runSignIn({ service, origin, locale, signal, open = openBrowser }) {
+  // An attempt already in flight is returned unchanged rather than replaced, so this also
+  // covers "resume the sign-in you started a moment ago".
+  const started = await service.startSignIn(locale, origin, 'desktop');
+  const attempt = started.attempt;
+  if (attempt === null || attempt === undefined) return { ok: false, lines: [t(locale, 'account.startFailed')] };
+  const lines = [t(locale, 'account.starting')];
+  // The browser URL is not part of `startSignIn`'s answer: the provider returns as soon as
+  // the attempt exists and publishes the URL once `auth_init` replies, so it is awaited
+  // before anything is opened.
+  const ready = await followAttempt(service, attempt.id, view => authorizeReady(view, attempt.id), signal);
+  const url = ready.attempt?.id === attempt.id ? ready.attempt.authorizeUrl : undefined;
+  if (url !== undefined) {
+    lines.push(await open(url) ? t(locale, 'account.browserOpened') : t(locale, 'account.browserManual'));
+    lines.push(url);
+  }
+  const final = settled(ready, attempt.id) ? ready : await followAttempt(service, attempt.id, view => settled(view, attempt.id), signal);
+  const details = final.status === 'credential-stored' ? await readDetails(service) : undefined;
+  return {
+    ok: final.attempt?.phase === 'succeeded' || final.status === 'credential-stored',
+    lines: [...lines, '', ...outcomeLines(final, details, locale)],
+  };
+}
+
+export function apply(ctx) {
+  const language = () => readLanguage();
+  const account = () => ctx.get('deepseekAccount');
+
+  ctx.commands.register({
+    name: 'account',
+    description: 'Sign in to a DeepSeek account through the browser, or read its status (/account [login|cancel|logout])',
+    input: { hint: '[login|cancel|logout]' },
+    handler: async ({ rawInput, signal }) => {
+      const locale = language();
+      const service = account();
+      const argument = String(rawInput ?? '').trim().toLowerCase();
+      if (service === undefined) return fail(t(locale, 'account.unavailable'));
+
+      if (argument === '' || argument === 'status') {
+        const view = await service.getState();
+        const details = view.status === 'credential-stored' ? await readDetails(service) : undefined;
+        return ok(statusLines(view, details, locale).join('\n'));
+      }
+
+      if (argument === 'logout' || argument === 'sign-out' || argument === 'signout') {
+        const view = await service.signOut();
+        return ok(statusLines(view, undefined, locale).join('\n'));
+      }
+
+      if (argument === 'cancel') {
+        const current = await service.getState();
+        const attempt = current.attempt;
+        if (attempt === null || !ACTIVE_PHASES.includes(attempt.phase)) return ok(t(locale, 'account.nothingToCancel'));
+        const view = await service.cancelSignIn(attempt.id);
+        return ok(outcomeLines(view, undefined, locale).join('\n'));
+      }
+
+      if (argument !== 'login' && argument !== 'signin' && argument !== 'sign-in') {
+        return fail(t(locale, 'account.usage'));
+      }
+
+      const origin = callbackOrigin(ctx.get('webServer'));
+      const blocked = signInBlocked(service, origin, locale);
+      if (blocked !== undefined) return fail(blocked);
+
+      const result = await runSignIn({ service, origin, locale, signal });
+      ctx.logger?.info?.(`account: sign-in ${result.ok ? 'succeeded' : 'did not complete'}`);
+      return (result.ok ? ok : fail)(result.lines.join('\n'));
+    },
+  });
+}
+
+/** Read identity and balance, letting either failure render on its own. */
+async function readDetails(service) {
+  const [profile, balance] = await Promise.all([
+    service.getProfile().catch(() => ({ status: 'failed' })),
+    service.getBalance().catch(() => ({ status: 'failed' })),
+  ]);
+  return { profile: profile ?? undefined, balance: balance ?? undefined };
+}

package/plugins/account/state.mjs

@@ -0,0 +1,123 @@
+/**
+ * Pure rendering and validation for the DeepSeek account surface.
+ *
+ * The account service (`@deepseek-ai/dsh-deepseek-account`) owns the login protocol: a
+ * system-browser sign-in with PKCE, a callback the provider registers on the Host
+ * webserver, and a grant kept in the local credential store. Nothing here touches that
+ * protocol — it turns one `AccountView` (plus the optional profile and balance reads)
+ * into the lines `/account` prints, so the command stays a thin driver and every rule
+ * below is testable without a Host.
+ *
+ * Credentials never reach this module: `AccountView` is the client-safe projection and
+ * carries no token.
+ *
+ * @module dscode-account/state
+ */
+
+import { t } from '../i18n/messages.mjs';
+
+/** Attempt phases that will not change again without a new sign-in. */
+export const TERMINAL_PHASES = Object.freeze(['succeeded', 'cancelled', 'expired', 'failed']);
+
+/** Phases during which a sign-in is still moving. */
+export const ACTIVE_PHASES = Object.freeze(['initializing', 'waiting-browser', 'exchanging', 'committing']);
+
+/**
+ * The browser-reachable callback origin for one sign-in.
+ *
+ * The provider accepts exactly `http://127.0.0.1:<port>` (or localhost/[::1]) with a
+ * non-zero explicit port and no path, because that is the loopback redirect the browser
+ * is sent back to. An unmounted or unbound webserver has no origin, and the caller
+ * reports that rather than starting an attempt that cannot complete.
+ *
+ * @param webServer - the Host webserver service, or undefined when none is composed.
+ * @returns the origin, or undefined when no login can be served.
+ */
+export function callbackOrigin(webServer) {
+  const port = webServer?.port;
+  if (!Number.isInteger(port) || port <= 0) return undefined;
+  return `http://127.0.0.1:${port}`;
+}
+
+/** One wallet as `12.34 CNY`, keeping the server's decimal string exactly. */
+export function formatWallet(wallet) {
+  return `${wallet.balance} ${wallet.currency}`;
+}
+
+/**
+ * The balance line, or undefined when the deployment reported none.
+ *
+ * Recharge and bonus wallets stay separate: upstream keeps them apart because a bonus
+ * wallet is not spendable credit in the same sense, and a failed query supplies neither.
+ */
+export function balanceLine(balance, locale) {
+  if (balance === undefined || balance === null) return undefined;
+  if (balance.status !== 'ready') return t(locale, 'account.balanceFailed');
+  const wallets = balance.value.map(formatWallet).join(', ');
+  const bonus = balance.bonusWallets.map(formatWallet).join(', ');
+  if (wallets === '' && bonus === '') return t(locale, 'account.balanceEmpty');
+  const parts = [wallets === '' ? undefined : wallets, bonus === '' ? undefined : t(locale, 'account.bonus', { wallets: bonus })];
+  return t(locale, 'account.balance', { wallets: parts.filter(Boolean).join(' · ') });
+}
+
+/** The identity line, or undefined when the deployment reported none. */
+export function profileLine(profile, locale) {
+  if (profile === undefined || profile === null) return undefined;
+  if (profile.status !== 'ready') return t(locale, 'account.profileFailed');
+  const { name, contact, id } = profile.value;
+  const identity = [name, contact].filter(value => typeof value === 'string' && value !== '').join(' · ');
+  return t(locale, 'account.profile', { identity: identity === '' ? (id ?? t(locale, 'account.unknownIdentity')) : identity });
+}
+
+/** One line for the latest attempt, including a terminal outcome, or undefined when there was none. */
+export function attemptLine(attempt, locale) {
+  if (attempt === null || attempt === undefined) return undefined;
+  const phase = t(locale, `account.phase.${attempt.phase}`);
+  if (attempt.errorCode === undefined) return t(locale, 'account.attempt', { phase });
+  return t(locale, 'account.attemptFailed', { phase, reason: t(locale, `account.error.${attempt.errorCode}`) });
+}
+
+/**
+ * Render `/account` with no argument: stored-credential status, the identity and balance
+ * when they were read, the latest attempt, and the platform's own pages.
+ *
+ * `credential-stored` is deliberately not a claim that the server still accepts the
+ * grant — upstream stores no expiry — so the wording says what is on this machine.
+ *
+ * @param view - client-safe account state.
+ * @param details - optional profile and balance reads; absent when signed out or unread.
+ * @param locale - DSCODE interface language.
+ * @returns the lines to print, in order.
+ */
+export function statusLines(view, details, locale) {
+  const signedIn = view.status === 'credential-stored';
+  const lines = [t(locale, signedIn ? 'account.signedIn' : 'account.signedOut')];
+  if (signedIn) {
+    for (const line of [profileLine(details?.profile, locale), balanceLine(details?.balance, locale)]) if (line !== undefined) lines.push(line);
+  }
+  const attempt = attemptLine(view.attempt, locale);
+  if (attempt !== undefined) lines.push(attempt);
+  lines.push(t(locale, 'account.links', { usage: view.links.usageUrl, topUp: view.links.topUpUrl }));
+  lines.push(t(locale, signedIn ? 'account.hintSignedIn' : 'account.hintSignedOut'));
+  return lines;
+}
+
+/**
+ * Why a sign-in cannot start, or undefined when it can.
+ *
+ * @param account - the account service, or undefined when the deployment composes none.
+ * @param origin - the resolved callback origin from {@link callbackOrigin}.
+ * @param locale - DSCODE interface language.
+ */
+export function signInBlocked(account, origin, locale) {
+  if (account === undefined) return t(locale, 'account.unavailable');
+  if (origin === undefined) return t(locale, 'account.noCallback');
+  return undefined;
+}
+
+/** The lines printed once an attempt settles. */
+export function outcomeLines(view, details, locale) {
+  const phase = view.attempt?.phase;
+  if (phase === 'succeeded') return statusLines(view, details, locale);
+  return [attemptLine(view.attempt, locale) ?? t(locale, 'account.signedOut')];
+}

package/plugins/auto-review/index.mjs

@@ -24,6 +24,9 @@ export function apply(ctx, config) {
   const calls = new WeakMap();
   const budgets = new WeakMap();
   const mode = agent => ctx.permissionPresets.current(agent.session);
+  // The preset this plugin reviews for. DSH 0.1.7 reserved `auto` for its own
+  // integration, so the reviewed preset carries DSCODE's own name.
+  const REVIEWED = 'auto-review';
   const stateFor = agent => {
     const events = agent.session.snapshotEvents();
     const turn = events.findLast(e => e.type === 'turn/start')?.seq;
@@ -54,7 +57,7 @@ export function apply(ctx, config) {
   });
 
   const announce = (agent, text) => agent.inject(createUserMessage({
-    content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: name },
+    content: [{ type: 'text', text }], source: { kind: name },
   }));
   const record = (req, data) => {
     audit.append(req.agent.session.id, { sessionSeq: req.agent.session.seq, callId: req.callId ?? null, toolName: req.toolName, ...data });
@@ -64,7 +67,7 @@ export function apply(ctx, config) {
   async function review(req, next, state) {
     if (req.signal?.aborted) return 'cancelled';
     // A user can switch to ask while a prior review waits in the queue.
-    if (mode(req.agent) !== 'auto') return ctx.approval?.effectivePolicy?.(req.agent.session) === 'never' ? 'rejected' : next();
+    if (mode(req.agent) !== REVIEWED) return ctx.approval?.effectivePolicy?.(req.agent.session) === 'never' ? 'rejected' : next();
     const exec = calls.get(req.agent)?.get(req.callId);
     const fallback = async (reason, details = {}) => {
       record(req, { decision: 'human', reason, ...details });
@@ -82,7 +85,7 @@ export function apply(ctx, config) {
         record(req, { decision: 'cancelled', reason: 'Caller cancelled review.', ...details });
         return 'cancelled';
       }
-      if (mode(req.agent) !== 'auto') return fallback('Permission mode changed while review was pending.', details);
+      if (mode(req.agent) !== REVIEWED) return fallback('Permission mode changed while review was pending.', details);
       if (decision.decision === 'human') return fallback(decision.reason, details);
       // Bind approval to the still-pending immutable invocation; no grant cache.
       if (calls.get(req.agent)?.get(req.callId) !== exec || fingerprint(action) !== actionHash) return fallback('Pending action changed during review.', details);
@@ -174,7 +177,7 @@ export function apply(ctx, config) {
           ...(effort === undefined ? {} : { reasoningEffort: effort }),
           messages: [createSystemMessage(REVIEW_POLICY, name), createUserMessage({
             content: [{ type: 'text', text: JSON.stringify({ action, context }) }],
-            source: { kind: 'plugin', plugin: name },
+            source: { kind: name },
           })],
           maxTokens: config.maxOutputTokens, signal,
         })) {
@@ -231,7 +234,7 @@ export function apply(ctx, config) {
       }
       announce(req.agent, `Escalation budget reached (${grantBudget} per turn); asking the user.`);
     }
-    if (mode(req.agent) !== 'auto') return next();
+    if (mode(req.agent) !== REVIEWED) return next();
     const state = stateFor(req.agent);
     // Serialize per agent so simultaneous calls cannot race the denial budget.
     const pending = state.tail.then(() => review(req, next, state));

package/plugins/code-review/index.mjs

@@ -141,7 +141,7 @@ export async function independentReview(ctx, agent, options = {}, signal, collec
         for await (const chunk of ctx.llm.stream({
           provider: route.provider, model: route.model, reasoningEffort, purpose: 'review',
           maxTokens: tokens,
-          system: POLICY, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(request) }], source: { kind: 'plugin', plugin: name } })], signal: deadline,
+          system: POLICY, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(request) }], source: { kind: name } })], signal: deadline,
         })) {
           deadline.throwIfAborted();
           assembler.push(chunk);

package/plugins/computer-use/index.mjs

@@ -0,0 +1,37 @@
+/**
+ * Computer Use, mounted through DSCODE so a retired settings API still resolves.
+ *
+ * `@anionex/dsh-computer-use` reads its configuration with `ctx.settings.register`, an API
+ * DSH removed in 0.1.7: Settings now projects forms from the profile entry itself, and the
+ * missing method made the whole Computer Use bundle fail to activate. The package is
+ * pinned at 0.3.2 with no newer release, so this row restores the method — as a read-only
+ * view over the composition config, which is where DSCODE configures Computer Use anyway —
+ * and then mounts the upstream bundle as its child, which is what makes the order
+ * dependable: the shim is installed before the provider's constructor runs.
+ *
+ * Retire this wrapper when the package reads volatile configuration, and mount
+ * `@anionex/dsh-computer-use` directly again.
+ *
+ * @module dscode-computer-use
+ */
+
+import ComputerUseBundle from '@anionex/dsh-computer-use';
+
+export const name = 'dscode-computer-use';
+export const inject = ['settings'];
+
+/** Section handle the 0.3.x provider expects: one read of the composition config, no live writes. */
+function staticSection(base) {
+  return { get: () => base, watch: () => () => {} };
+}
+
+export function apply(ctx, config = {}) {
+  const settings = ctx.settings;
+  // Only ever adds what upstream no longer defines; a Settings service that carries its
+  // own `register` again is left untouched, and the shim is dropped with this row.
+  if (typeof settings.register !== 'function') {
+    settings.register = (_namespace, _schema, options = {}) => staticSection(options.base ?? {});
+    ctx.effect(() => () => { delete settings.register; });
+  }
+  ctx.plugin(ComputerUseBundle, config);
+}

package/plugins/cordis-config/plain.mjs

@@ -0,0 +1,31 @@
+/**
+ * One plain snapshot of a Cordis plugin configuration.
+ *
+ * Two shapes make a foreign entry's `config` unusable as a plain object. DSH 0.1.7 hands
+ * a `.volatile()` field to its own plugin as a reference rather than a value, and the
+ * Loader keeps a YAML `!!js` scalar as an unevaluated `{ __jsExpr }` node until the entry
+ * activates — which a reader inspecting another entry's row (the skills conflict report
+ * walks every `skill-filesystem` entry, and a preset's rows carry such expressions) sees
+ * instead of the value. References are read; an expression cannot be evaluated outside the
+ * Loader's own scope, so it reads as absent and the caller applies its own fallback.
+ *
+ * @param config - a configuration object whose fields may be references or expressions.
+ * @returns a shallow copy carrying only plainly readable values.
+ */
+export function plainConfig(config) {
+  if (config === null || typeof config !== 'object') return {};
+  const entries = Object.entries(config)
+    .map(([key, value]) => [key, isReference(value) ? value.get() : value])
+    .filter(([, value]) => !isExpression(value));
+  return Object.fromEntries(entries);
+}
+
+/** Whether a configuration field is a Cordis value reference rather than a plain value. */
+function isReference(value) {
+  return value !== null && typeof value === 'object' && typeof value.get === 'function';
+}
+
+/** Whether a configuration field is still an unevaluated Loader expression node. */
+function isExpression(value) {
+  return value !== null && typeof value === 'object' && '__jsExpr' in value;
+}

package/plugins/dscode/index.mjs

@@ -30,7 +30,7 @@ const DELEGATION_TOOLS = ['subagent', 'subagent_fork', 'workflow', 'ralph'];
 // repository there instead of pointing at a path that does not exist.
 const DOCS_DIR = fileURLToPath(new URL('../../docs/', import.meta.url));
 const DOCS_REPO = 'https://github.com/qiz029/dscode/blob/main/docs/';
-export const DOCS_SECTION = `To answer questions about DSCODE itself - what it supports, how a feature is configured, what a command does - treat the bundled user guides as the source of truth instead of guessing: ${existsSync(DOCS_DIR) ? `${DOCS_DIR} plus the repository root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, demo.md, triggers.md)` : `the repository documentation at ${DOCS_REPO} plus the root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, demo.md, triggers.md)`}. Read the relevant guide before answering rather than relying on memory of an earlier session. docs/CONTEXT-HANDOFF.md, docs/session-messaging-design.md, docs/cloud-webapp-host.md, docs/triggers-design.md, docs/verification.md, docs/maintainability.md and docs/vendored-tui-upgrade.md are internal development records, not user documentation: never quote them to a user or treat them as a specification. When the guides do not cover something, describe only what the running installation actually does and say plainly that it is not documented.`;
+export const DOCS_SECTION = `To answer questions about DSCODE itself - what it supports, how a feature is configured, what a command does - treat the bundled user guides as the source of truth instead of guessing: ${existsSync(DOCS_DIR) ? `${DOCS_DIR} plus the repository root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, demo.md, triggers.md)` : `the repository documentation at ${DOCS_REPO} plus the root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, email.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, demo.md, triggers.md)`}. Read the relevant guide before answering rather than relying on memory of an earlier session. docs/CONTEXT-HANDOFF.md, docs/session-messaging-design.md, docs/cloud-webapp-host.md, docs/triggers-design.md, docs/verification.md, docs/maintainability.md and docs/vendored-tui-upgrade.md are internal development records, not user documentation: never quote them to a user or treat them as a specification. When the guides do not cover something, describe only what the running installation actually does and say plainly that it is not documented.`;
 
 export function apply(ctx) {
   ctx.systemPrompt.section({ name: 'dscode:shell-policy', order: 1050, text: SHELL_POLICY });

package/plugins/exec/cli.mjs

@@ -9,7 +9,7 @@ Options:
   --cwd DIR             workspace for the agent (default: current directory)
   --model PROVIDER/ID   model route (default: the saved default model)
   --effort LEVEL        reasoning effort the model offers: off, minimal, low, medium, high, xhigh, max or ultra
-  --permission PRESET   permission preset: auto, ask, workspace-write, read-only, danger-full-access
+  --permission PRESET   permission preset: auto-review, ask, workspace-write, read-only, danger-full-access
   --approve-all         answer every approval request with allow (no human is present)
   --resume SESSION_ID   continue an existing session instead of starting a new one
   --json                emit JSON lines (session, text, tool, result) instead of plain text

package/plugins/grok/index.mjs

@@ -1,6 +1,8 @@
 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";
@@ -19,14 +21,18 @@ 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),
-  baseURL: z.string().default(DEFAULT_BASE_URL),
-  clientVersion: z.string().default(DEFAULT_CLIENT_VERSION),
-  streamIdleTimeoutMs: z.number().min(1).default(300000),
-  retryPolicy: RetryPolicySchema,
+  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;
@@ -50,18 +56,18 @@ export function loginHint(state) {
 }
 
 export function apply(ctx, config = {}) {
-  let current = () => config, lastRaw, lastGood;
+  // 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 = () => {
-    const raw = current();
-    if (raw === lastRaw && lastGood !== undefined) return lastGood;
     try {
-      lastGood = resolveOptions(raw);
-      lastRaw = raw;
+      lastGood = resolveOptions(plainConfig(config));
       return lastGood;
     } catch (error) {
       if (lastGood === undefined) throw error;
-      lastRaw = raw;
-      ctx.logger.error(name + ": keeping the last good configuration after an invalid settings section");
+      ctx.logger.error(name + ": keeping the last good configuration after an invalid edit");
       return lastGood;
     }
   };
@@ -89,19 +95,17 @@ export function apply(ctx, config = {}) {
     await ensureGrokModels({ home, token, version: options().clientVersion });
   };
   const adapter = new GrokAdapter({ options, ensureModels, resolveToken });
-  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: "Grok", settingsNs: NS, settingsPath: [] }]);
+  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: "Grok", settingsNs: ctx.fiber.entry?.options.id ?? NS, settingsPath: [] }]);
   const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
-  let registeredPolicy = JSON.stringify(options().retryPolicy);
-  ctx.inject(["settings"], settingsCtx => {
-    settingsCtx.settings.installSection(ctx, NS, Config, config, {
-      setSource: source => { current = source; },
-      onChange: () => {
-        const policy = JSON.stringify(options().retryPolicy);
-        if (policy === registeredPolicy) return;
-        registration.replace([PROVIDER]);
-        registeredPolicy = policy;
-      },
-    });
+  // 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).