dsh-grok-provider 0.1.0

package/dist/client/client.js

@@ -0,0 +1,215 @@
+/* global document, window */
+
+window.__ModuleLoader__.load({
+  id: "dsh-grok-provider",
+  factory: (require) => {
+    const module = { exports: {} }
+    const React = require("react")
+    const namespace = "settings.grok"
+    const dictionaries = {
+      zh: {
+        nav: "Grok Build", title: "Grok Build",
+        description: "管理官方 Grok Build 登录、账户额度与当前账号可用模型。敏感凭据不会发送到设置页面。",
+        loopback: "账户管理只允许在本机页面使用。", loading: "正在读取账户状态…", unavailable: "账户服务暂时不可用。",
+        ready: "已登录", notReady: "未登录", driverMissing: "官方 CLI 登录能力不可用",
+        running: "登录进行中", succeeded: "登录成功", failed: "登录失败", cancelled: "登录已取消",
+        login: "通过浏览器登录", cancel: "取消登录", logout: "退出登录", confirmLogout: "再次点击确认退出",
+        officialBody: "登录与凭据刷新由本机官方 Grok CLI 完成。退出会同时影响使用同一 Grok 凭据的其他应用。",
+        usage: "使用额度", grokBuild: "Grok Build", refresh: "刷新", refreshing: "刷新中…",
+        weekly: "每周额度", monthly: "每月额度", currentPeriod: "当前额度周期",
+        remaining: "剩余", used: "已使用", resetTime: "重置时间", resetUnknown: "上游未提供重置时间",
+        usageUnknown: "上游未提供使用比例", quotaUnavailable: "暂时无法读取 Grok Build 额度。",
+        modelsTitle: "当前账号可用的模型", modelsDescription: "模型来自 Grok Build 动态目录；Harness 模型选择器会显示这里列出的全部模型。",
+        modelsUnavailable: "暂时无法读取模型目录。", noModels: "当前账号没有返回可用模型。",
+        context: "上下文", reasoning: "推理档位", defaultEffort: "默认", text: "文本输入", streaming: "流式输出", tools: "工具调用",
+        lastUpdated: "数据更新时间",
+      },
+      en: {
+        nav: "Grok Build", title: "Grok Build",
+        description: "Manage official Grok Build sign-in, account quota, and models available to this account. Sensitive credentials never reach this page.",
+        loopback: "Account management is available only from the local page.", loading: "Reading account status…", unavailable: "The account service is temporarily unavailable.",
+        ready: "Signed in", notReady: "Signed out", driverMissing: "Official CLI sign-in unavailable",
+        running: "Sign-in in progress", succeeded: "Signed in", failed: "Sign-in failed", cancelled: "Sign-in cancelled",
+        login: "Sign in with browser", cancel: "Cancel sign-in", logout: "Sign out", confirmLogout: "Click again to confirm sign-out",
+        officialBody: "The official local Grok CLI owns sign-in and credential refresh. Signing out also affects other apps sharing the same Grok credential.",
+        usage: "Usage quota", grokBuild: "Grok Build", refresh: "Refresh", refreshing: "Refreshing…",
+        weekly: "Weekly quota", monthly: "Monthly quota", currentPeriod: "Current quota period",
+        remaining: "remaining", used: "Used", resetTime: "Resets", resetUnknown: "Reset time was not provided",
+        usageUnknown: "Usage percentage was not provided", quotaUnavailable: "Grok Build quota is temporarily unavailable.",
+        modelsTitle: "Models available to this account", modelsDescription: "Models come from the live Grok Build catalog; every model listed here remains visible in the Harness model selector.",
+        modelsUnavailable: "The model catalog is temporarily unavailable.", noModels: "This account returned no available models.",
+        context: "Context", reasoning: "Reasoning", defaultEffort: "default", text: "Text input", streaming: "Streaming", tools: "Tool calling",
+        lastUpdated: "Updated",
+      },
+    }
+
+    const css = `
+      .dsh-grok-page{box-sizing:border-box;width:min(920px,100%);padding:8px 4px 40px;color:var(--dsw-alias-label-primary)}
+      .dsh-grok-page *{box-sizing:border-box}.dsh-grok-page h2{margin:0;font-size:21px;line-height:31px}.dsh-grok-description{max-width:760px;margin:5px 0 18px;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:21px}
+      .dsh-grok-stack{display:grid;gap:14px}.dsh-grok-panel{overflow:hidden;border:1px solid rgb(190 93 138 / 28%);border-radius:18px;background:linear-gradient(145deg,rgb(190 93 138 / 8%),rgb(190 93 138 / 3%) 55%,var(--dsw-alias-bg-layer-1));box-shadow:0 1px 2px rgb(20 20 30 / 3%)}
+      .dsh-grok-panel-inner{padding:20px}.dsh-grok-account-head{display:flex;align-items:center;justify-content:space-between;gap:16px}.dsh-grok-state{display:flex;min-width:0;align-items:center;gap:10px;font-size:17px;font-weight:650}.dsh-grok-dot{width:10px;height:10px;flex:0 0 auto;border-radius:50%;background:var(--dsw-alias-label-tertiary,#909090)}.dsh-grok-dot[data-good="true"]{background:var(--dsw-static-green-500,#1ebf68);box-shadow:0 0 0 4px rgb(30 191 104 / 10%)}.dsh-grok-dot[data-running="true"]{background:#d99b2b;box-shadow:0 0 0 4px rgb(217 155 43 / 12%)}
+      .dsh-grok-button{height:36px;border:1px solid var(--dsw-alias-border-l2);border-radius:999px;padding:0 14px;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-layer-1);cursor:pointer;font:inherit;font-size:12px}.dsh-grok-button:hover:not(:disabled){color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}.dsh-grok-button:disabled{cursor:default;opacity:.45}.dsh-grok-primary{border-color:var(--dsw-static-deepseek-500,#4d6bfe);color:#fff;background:var(--dsw-static-deepseek-500,#4d6bfe)}
+      .dsh-grok-auth-note{margin:13px 0 0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:19px}.dsh-grok-actions{display:flex;flex-wrap:wrap;gap:7px}
+      .dsh-grok-divider{height:1px;margin:18px 0;background:rgb(190 93 138 / 20%)}.dsh-grok-section-head{display:flex;align-items:center;justify-content:space-between;gap:12px}.dsh-grok-section-head h3{margin:0;font-size:15px;line-height:23px}.dsh-grok-section-head .dsh-grok-button{height:30px;padding:0 11px}
+      .dsh-grok-quota{margin-top:15px}.dsh-grok-quota-row{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-bottom:8px;color:var(--dsw-alias-label-secondary);font-size:13px}.dsh-grok-quota-name{color:var(--dsw-alias-label-primary);font-weight:600}.dsh-grok-progress{height:9px;overflow:hidden;border-radius:999px;background:rgb(190 93 138 / 13%)}.dsh-grok-progress-fill{height:100%;border-radius:inherit;background:linear-gradient(90deg,#d7448a,#ea1768);transition:width .25s ease}.dsh-grok-quota-meta{display:flex;flex-wrap:wrap;justify-content:space-between;gap:7px;margin-top:9px;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}.dsh-grok-muted{margin:12px 0 0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:19px}
+      .dsh-grok-models-head{padding:20px 20px 0}.dsh-grok-models-head h3{margin:0;font-size:16px;line-height:24px}.dsh-grok-models-head p{margin:5px 0 0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:19px}.dsh-grok-model-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;padding:16px 20px 20px}.dsh-grok-model{min-width:0;border:1px solid var(--dsw-alias-border-l2);border-radius:13px;padding:14px;background:var(--dsw-alias-bg-layer-1)}.dsh-grok-model-title{display:flex;align-items:baseline;justify-content:space-between;gap:8px}.dsh-grok-model-title strong{overflow-wrap:anywhere;font-size:14px}.dsh-grok-model-id{overflow-wrap:anywhere;color:var(--dsw-alias-label-tertiary,var(--dsw-alias-label-secondary));font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:10px}.dsh-grok-model-description{margin:5px 0 10px;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:17px}.dsh-grok-badges{display:flex;flex-wrap:wrap;gap:5px}.dsh-grok-badge{border-radius:999px;padding:2px 8px;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-interactive-bg-hover);font-size:10px;line-height:18px}.dsh-grok-badge[data-accent="true"]{color:#a9326b;background:rgb(215 68 138 / 11%)}.dsh-grok-efforts{margin-top:10px;color:var(--dsw-alias-label-secondary);font-size:10px;line-height:17px}.dsh-grok-footer{padding:0 20px 16px;color:var(--dsw-alias-label-tertiary,var(--dsw-alias-label-secondary));font-size:10px}
+      .dsh-grok-notice{padding:13px 14px;border:1px solid rgb(229 72 77 / 28%);border-radius:11px;color:var(--dsw-alias-label-secondary);background:rgb(229 72 77 / 7%);font-size:12px;line-height:19px}.dsh-grok-error{margin:10px 0 0;color:var(--dsw-static-red-500,#e5484d);font-size:12px}
+      @media(max-width:680px){.dsh-grok-panel-inner,.dsh-grok-models-head{padding:16px}.dsh-grok-model-grid{grid-template-columns:1fr;padding:14px 16px 16px}.dsh-grok-account-head{align-items:flex-start;flex-direction:column}.dsh-grok-quota-row{align-items:flex-start;flex-direction:column;gap:3px}}
+    `
+    if (!document.querySelector('style[data-plugin-css="dsh-grok-provider"]')) {
+      const style = document.createElement("style")
+      style.dataset.pluginCss = "dsh-grok-provider"
+      style.textContent = css
+      document.head.appendChild(style)
+    }
+
+    function GrokSettings({ connection, t }) {
+      const [status, setStatus] = React.useState()
+      const [dashboard, setDashboard] = React.useState()
+      const [busy, setBusy] = React.useState(false)
+      const [error, setError] = React.useState(false)
+      const [dashboardError, setDashboardError] = React.useState(false)
+      const [confirmLogout, setConfirmLogout] = React.useState(false)
+      const call = React.useCallback(async (endpoint, payload = {}) => {
+        const result = await connection.rpc.call("/grok-auth", endpoint, payload)
+        if (!result || result.ok !== true) throw new Error("Grok account RPC failed")
+        return result.value
+      }, [connection])
+      const refreshDashboard = React.useCallback(async () => {
+        try {
+          const value = await call("dashboard")
+          setDashboard(value.dashboard)
+          setDashboardError(false)
+        } catch { setDashboardError(true) }
+      }, [call])
+      const refreshStatus = React.useCallback(async ({ includeDashboard = false } = {}) => {
+        try {
+          const value = await call("status")
+          setStatus(value.status)
+          setError(false)
+          if (value.status.available === true && includeDashboard) await refreshDashboard()
+          if (value.status.available !== true) setDashboard(undefined)
+        } catch { setError(true) }
+      }, [call, refreshDashboard])
+      React.useEffect(() => { refreshStatus({ includeDashboard: true }) }, [refreshStatus])
+      React.useEffect(() => {
+        if (status?.session?.state !== "running") return undefined
+        const timer = window.setInterval(() => refreshStatus(), 1_000)
+        return () => window.clearInterval(timer)
+      }, [refreshStatus, status])
+      React.useEffect(() => {
+        if (status?.available === true && status?.session?.state === "succeeded") refreshDashboard()
+      }, [refreshDashboard, status?.available, status?.session?.state])
+      const act = async (operation) => {
+        setBusy(true); setError(false)
+        try { await operation() } catch { setError(true) } finally { setBusy(false) }
+      }
+      const login = () => act(async () => {
+        await call("login"); setConfirmLogout(false); await refreshStatus()
+      })
+      const cancel = () => act(async () => {
+        const sessionId = status?.session?.sessionId
+        if (typeof sessionId !== "string") throw new Error("No active Grok login")
+        await call("cancel", { sessionId }); await refreshStatus({ includeDashboard: true })
+      })
+      const logout = () => act(async () => {
+        const value = await call("logout")
+        if (value.kind === "logout-confirmation-required") setConfirmLogout(true)
+        else { setConfirmLogout(false); setDashboard(undefined); await refreshStatus() }
+      })
+      const manualRefresh = () => act(async () => refreshStatus({ includeDashboard: true }))
+
+      if (!connection.isLoopback) return React.createElement("section", { className: "dsh-grok-page" },
+        React.createElement("h2", null, t("title")), React.createElement("p", { className: "dsh-grok-notice" }, t("loopback")))
+      if (!status && !error) return React.createElement("section", { className: "dsh-grok-page" }, t("loading"))
+
+      const driver = status?.driver === true
+      const available = status?.available === true
+      const sessionState = status?.session?.state
+      const stateLabel = !driver ? t("driverMissing") : sessionState === "running" ? t("running")
+        : sessionState === "succeeded" && available ? t("succeeded") : sessionState === "failed" ? t("failed")
+          : sessionState === "cancelled" ? t("cancelled") : available ? t("ready") : t("notReady")
+
+      const renderQuota = () => {
+        if (!available) return React.createElement("p", { className: "dsh-grok-muted" }, t("notReady"))
+        if (!dashboard && !dashboardError) return React.createElement("p", { className: "dsh-grok-muted" }, t("refreshing"))
+        const quota = dashboard?.quota
+        if (dashboardError || quota?.state !== "ready") return React.createElement("p", { className: "dsh-grok-muted" }, t("quotaUnavailable"))
+        const hasPercent = typeof quota.remainingPercent === "number"
+        const periodLabel = quota.periodKind === "weekly" ? t("weekly") : quota.periodKind === "monthly" ? t("monthly") : t("currentPeriod")
+        return React.createElement("div", { className: "dsh-grok-quota" },
+          React.createElement("div", { className: "dsh-grok-quota-row" },
+            React.createElement("span", { className: "dsh-grok-quota-name" }, t("grokBuild")),
+            React.createElement("span", null, hasPercent ? `${t("remaining")} ${formatPercent(quota.remainingPercent)}` : t("usageUnknown"))),
+          hasPercent && React.createElement("div", { className: "dsh-grok-progress", role: "progressbar", "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": quota.remainingPercent },
+            React.createElement("div", { className: "dsh-grok-progress-fill", style: { width: `${quota.remainingPercent}%` } })),
+          React.createElement("div", { className: "dsh-grok-quota-meta" },
+            React.createElement("span", null, hasPercent ? `${periodLabel} · ${t("used")} ${formatPercent(quota.usedPercent)}` : periodLabel),
+            React.createElement("span", null, quota.resetsAt ? `${t("resetTime")}：${formatDateTime(quota.resetsAt)}` : t("resetUnknown"))))
+      }
+
+      const renderModel = (model) => {
+        const effortText = model.reasoning?.efforts?.map((effort) => effort.id === model.reasoning.defaultEffort
+          ? `${effort.name} (${t("defaultEffort")})` : effort.name).join(" · ")
+        return React.createElement("article", { className: "dsh-grok-model", key: model.id },
+          React.createElement("div", { className: "dsh-grok-model-title" },
+            React.createElement("strong", null, model.name), React.createElement("span", { className: "dsh-grok-model-id" }, model.id)),
+          model.description && React.createElement("p", { className: "dsh-grok-model-description" }, model.description),
+          React.createElement("div", { className: "dsh-grok-badges" },
+            React.createElement("span", { className: "dsh-grok-badge", "data-accent": true }, `${t("context")} ${formatContext(model.contextWindow)}`),
+            model.capabilities?.textInput && React.createElement("span", { className: "dsh-grok-badge" }, t("text")),
+            model.capabilities?.streaming && React.createElement("span", { className: "dsh-grok-badge" }, t("streaming")),
+            model.capabilities?.functionTools && React.createElement("span", { className: "dsh-grok-badge" }, t("tools"))),
+          effortText && React.createElement("div", { className: "dsh-grok-efforts" }, `${t("reasoning")}：${effortText}`))
+      }
+
+      const models = dashboard?.models
+      return React.createElement("section", { className: "dsh-grok-page" },
+        React.createElement("h2", null, t("title")), React.createElement("p", { className: "dsh-grok-description" }, t("description")),
+        React.createElement("div", { className: "dsh-grok-stack" },
+          React.createElement("article", { className: "dsh-grok-panel" }, React.createElement("div", { className: "dsh-grok-panel-inner" },
+            React.createElement("div", { className: "dsh-grok-account-head" },
+              React.createElement("div", { className: "dsh-grok-state" }, React.createElement("span", { className: "dsh-grok-dot", "data-good": available, "data-running": sessionState === "running" }), stateLabel),
+              React.createElement("div", { className: "dsh-grok-actions" },
+                sessionState === "running"
+                  ? React.createElement("button", { className: "dsh-grok-button", type: "button", disabled: busy, onClick: cancel }, t("cancel"))
+                  : !available && React.createElement("button", { className: "dsh-grok-button dsh-grok-primary", type: "button", disabled: busy || !driver, onClick: login }, t("login")),
+                available && React.createElement("button", { className: "dsh-grok-button", type: "button", disabled: busy || !driver, onClick: logout }, t(confirmLogout ? "confirmLogout" : "logout")))),
+            React.createElement("p", { className: "dsh-grok-auth-note" }, t("officialBody")),
+            React.createElement("div", { className: "dsh-grok-divider" }),
+            React.createElement("div", { className: "dsh-grok-section-head" }, React.createElement("h3", null, t("usage")),
+              React.createElement("button", { className: "dsh-grok-button", type: "button", disabled: busy || !available, onClick: manualRefresh }, busy ? t("refreshing") : t("refresh"))),
+            renderQuota(), error && React.createElement("p", { className: "dsh-grok-error" }, t("unavailable")))),
+          React.createElement("article", { className: "dsh-grok-panel" },
+            React.createElement("div", { className: "dsh-grok-models-head" }, React.createElement("h3", null, t("modelsTitle")), React.createElement("p", null, t("modelsDescription"))),
+            React.createElement("div", { className: "dsh-grok-model-grid" },
+              !available ? React.createElement("p", { className: "dsh-grok-muted" }, t("notReady"))
+                : dashboardError || models?.state === "unavailable" ? React.createElement("p", { className: "dsh-grok-muted" }, t("modelsUnavailable"))
+                  : !models ? React.createElement("p", { className: "dsh-grok-muted" }, t("refreshing"))
+                    : models.items.length === 0 ? React.createElement("p", { className: "dsh-grok-muted" }, t("noModels"))
+                      : models.items.map(renderModel)),
+            dashboard?.fetchedAt && React.createElement("div", { className: "dsh-grok-footer" }, `${t("lastUpdated")}：${formatDateTime(dashboard.fetchedAt)}`))))
+    }
+
+    function formatPercent(value) { return `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 2 }).format(value)}%` }
+    function formatDateTime(value) { return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value)) }
+    function formatContext(value) {
+      if (value >= 1_000_000) return `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 1 }).format(value / 1_000_000)}M`
+      if (value >= 1_000) return `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 0 }).format(value / 1_000)}K`
+      return new Intl.NumberFormat().format(value)
+    }
+
+    const inject = ["slots", "locale", "connection"]
+    function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(namespace, dictionaries), "dsh-grok: dictionaries")
+      const t = ctx.locale.bind(namespace)
+      ctx.slots.inject("settings.section", () => ctx.slots.register({
+        name: "settings.section", id: "grok-auth", order: 45, label: () => t("nav"), locale: namespace,
+        inject: () => ({ connection: ctx.connection, t }),
+      }, GrokSettings))
+    }
+    module.exports.inject = inject
+    module.exports.apply = apply
+    return module.exports
+  },
+})

package/dist/host/index.mjs

@@ -0,0 +1,147 @@
+import os from "node:os"
+import path from "node:path"
+import { randomUUID } from "node:crypto"
+
+import { LlmError, attributionHeaders } from "@deepseek-ai/dsh-llm"
+import Schema from "@deepseek-ai/schemastery"
+
+import {
+  CredentialFileTooLargeError,
+  GROK_CLI_1_0_5_AUTH_CONTRACT,
+  UnsupportedCredentialError,
+  createCredentialSource,
+} from "../internal/credential-source.mjs"
+import { AuthModeUnavailableError } from "../internal/auth-registry.mjs"
+import { createAccountDashboard } from "../internal/account-dashboard.mjs"
+import { createAuthController } from "../internal/auth-controller.mjs"
+import { createAuthRpcHandler } from "../internal/auth-rpc.mjs"
+import { createGrokAdapter } from "../internal/grok-adapter.mjs"
+import { createGrokCommandHandler } from "../internal/grok-command-handler.mjs"
+import { GrokTransportError, createGrokTransport } from "../internal/grok-transport.mjs"
+import {
+  OfficialCredentialFileError,
+  createOfficialCredentialLoader,
+} from "../internal/official-credential-loader.mjs"
+import { createOfficialCliAuth } from "../internal/official-cli-auth.mjs"
+import { createOfficialAuthDriver } from "../internal/official-auth-driver.mjs"
+import { verifyOfficialCliExecutable } from "../internal/official-cli-verifier.mjs"
+import { installProviderRuntime } from "../internal/provider-runtime.mjs"
+
+export const name = "llm-grok"
+export const inject = ["llm"]
+
+export const Config = Schema.object({})
+
+export function apply(ctx) {
+  const platform = process.platform
+  if (platform !== "darwin" && platform !== "win32") {
+    throw new TypeError("dsh-grok-provider supports macOS and Windows in version 0.1.0")
+  }
+
+  const homeDir = os.homedir()
+  let refreshOfficialCredential
+  const officialSource = createCredentialSource({
+    contract: GROK_CLI_1_0_5_AUTH_CONTRACT,
+    load: createOfficialCredentialLoader({
+      authPath: path.join(homeDir, ".grok", "auth.json"),
+      platform,
+    }),
+    now: () => new Date(),
+    refresh: async () => {
+      if (refreshOfficialCredential === undefined) throw new UnsupportedCredentialError()
+      await refreshOfficialCredential()
+    },
+  })
+  const runtime = installProviderRuntime({
+    llm: ctx.llm,
+    officialSource,
+    createTransport: (credentialSource) => createGrokTransport({
+      credentialSource,
+      fetch: globalThis.fetch,
+      attributionHeaders,
+      clientIdentifier: "dsh-grok-provider",
+      clientVersion: "1.0.5",
+    }),
+    createAdapter: ({ getGeneration }) => createGrokAdapter({
+      getGeneration,
+      mapError: mapLlmError,
+    }),
+  })
+  const authController = createAuthController({
+    registry: runtime.auth,
+    randomUUID,
+  })
+  const commandHandler = createGrokCommandHandler({ controller: authController })
+  const dashboard = createAccountDashboard({
+    listModels: () => runtime.adapter.listModels("grok"),
+    getBilling: ({ signal } = {}) => runtime.auth.getGeneration().transport.getBilling({ signal }),
+    now: () => new Date(),
+  })
+  const authRpcHandler = createAuthRpcHandler({ controller: authController, dashboard })
+
+  ctx.inject(["subprocess"], (subprocessCtx) => {
+    const officialAuth = createOfficialCliAuth({
+      subprocess: subprocessCtx.subprocess,
+      platform,
+      homeDir,
+      verifyExecutable: verifyOfficialCliExecutable,
+    })
+    const refresh = async () => {
+      const outcome = await officialAuth.refresh()
+      if (outcome.kind !== "succeeded") throw new UnsupportedCredentialError()
+    }
+    refreshOfficialCredential = refresh
+    const removeDriver = authController.installDriver(createOfficialAuthDriver({
+      officialAuth,
+      credentialSource: officialSource,
+    }))
+    return async () => {
+      await authController.shutdown()
+      if (refreshOfficialCredential === refresh) refreshOfficialCredential = undefined
+      removeDriver()
+    }
+  })
+
+  ctx.inject(["commands"], (commandsCtx) => commandsCtx.commands.register({
+    name: "grok",
+    description: "Manage Grok Build authentication",
+    input: { hint: "status|login|cancel|logout" },
+    recordInput: false,
+    handler: commandHandler,
+  }))
+  ctx.inject(["connection"], (connectionCtx) => connectionCtx.connection.rpc.handle(
+    "/grok-auth",
+    authRpcHandler,
+    { authority: "loopback" },
+  ))
+
+  ctx.effect(() => () => runtime.dispose(), "llm-grok runtime")
+}
+
+function mapLlmError(error) {
+  if (error instanceof LlmError) return error
+  if (error?.name === "AbortError") {
+    return new LlmError("The Grok Build request was cancelled", "ABORTED", { cause: error })
+  }
+  if (
+    error instanceof AuthModeUnavailableError ||
+    error instanceof UnsupportedCredentialError ||
+    error instanceof CredentialFileTooLargeError ||
+    error instanceof OfficialCredentialFileError ||
+    (error instanceof GrokTransportError && (error.status === 401 || error.status === 403))
+  ) {
+    return new LlmError("Grok authentication is required", "AUTH", {
+      cause: error,
+      ...(error.status === undefined ? {} : { status: error.status }),
+    })
+  }
+  if (error instanceof GrokTransportError) {
+    return new LlmError("The Grok Build request failed", error.status === 429 ? "RATE_LIMIT" : "PROVIDER_ERROR", {
+      cause: error,
+      ...(error.status === undefined ? {} : { status: error.status }),
+    })
+  }
+  return new LlmError("The Grok provider rejected an invalid or unsupported response", "INVALID_RESPONSE", {
+    cause: error,
+  })
+}

package/dist/internal/account-dashboard.mjs

@@ -0,0 +1,67 @@
+import { parseBillingSummary } from "./billing-summary.mjs"
+
+export function createAccountDashboard({ listModels, getBilling, now }) {
+  if (typeof listModels !== "function" || typeof getBilling !== "function" || typeof now !== "function") {
+    throw new TypeError("Invalid Grok account dashboard dependencies")
+  }
+
+  return async function getAccountDashboard({ signal } = {}) {
+    const [modelResult, quotaResult] = await Promise.allSettled([
+      Promise.resolve().then(() => listModels({ signal })).then((models) => models.map(projectModel)),
+      Promise.resolve().then(() => getBilling({ signal })).then(parseBillingSummary),
+    ])
+    const currentTime = now()
+    if (!(currentTime instanceof Date) || !Number.isFinite(currentTime.getTime())) {
+      throw new TypeError("Invalid Grok account dashboard clock")
+    }
+    return Object.freeze({
+      fetchedAt: currentTime.toISOString(),
+      models: modelResult.status === "fulfilled"
+        ? Object.freeze({ state: "ready", items: Object.freeze(modelResult.value) })
+        : Object.freeze({ state: "unavailable", items: Object.freeze([]) }),
+      quota: quotaResult.status === "fulfilled"
+        ? quotaResult.value
+        : Object.freeze({ state: "unavailable" }),
+    })
+  }
+}
+
+function projectModel(model) {
+  if (
+    !isPlainObject(model) ||
+    typeof model.id !== "string" ||
+    typeof model.name !== "string" ||
+    !isPlainObject(model.context) ||
+    !Number.isSafeInteger(model.context.contextWindow)
+  ) throw new TypeError("Invalid Grok dashboard model")
+  return Object.freeze({
+    id: model.id,
+    name: model.name,
+    ...(typeof model.description === "string" ? { description: model.description } : {}),
+    contextWindow: model.context.contextWindow,
+    ...(model.reasoning === undefined ? {} : { reasoning: projectReasoning(model.reasoning) }),
+    capabilities: Object.freeze({ textInput: true, streaming: true, functionTools: true }),
+  })
+}
+
+function projectReasoning(reasoning) {
+  if (!isPlainObject(reasoning) || !Array.isArray(reasoning.efforts)) {
+    throw new TypeError("Invalid Grok dashboard reasoning capability")
+  }
+  const efforts = reasoning.efforts.map((effort) => {
+    if (!isPlainObject(effort) || typeof effort.id !== "string" || typeof effort.name !== "string") {
+      throw new TypeError("Invalid Grok dashboard reasoning effort")
+    }
+    return Object.freeze({ id: effort.id, name: effort.name })
+  })
+  return Object.freeze({
+    efforts: Object.freeze(efforts),
+    ...(typeof reasoning.defaultEffort === "string" ? { defaultEffort: reasoning.defaultEffort } : {}),
+  })
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}

package/dist/internal/auth-controller.mjs

@@ -0,0 +1,184 @@
+const OUTCOMES = new Set(["succeeded", "cancelled", "failed"])
+
+export class AuthLoginBusyError extends Error {
+  constructor() {
+    super("A Grok login or logout is already running")
+    this.name = "AuthLoginBusyError"
+  }
+}
+
+export class AuthDriverUnavailableError extends Error {
+  constructor() {
+    super("The official Grok authentication driver is unavailable")
+    this.name = "AuthDriverUnavailableError"
+  }
+}
+
+export function createAuthController({ registry, randomUUID, now = () => new Date(), driver }) {
+  if (
+    !registry ||
+    typeof registry.invalidate !== "function" ||
+    typeof registry.status !== "function" ||
+    typeof randomUUID !== "function" ||
+    typeof now !== "function"
+  ) throw new TypeError("Invalid Grok auth controller dependencies")
+
+  let installed
+  let active
+  let state
+  let confirmation
+  let closing = false
+  if (driver !== undefined) install(driver)
+
+  function install(nextDriver) {
+    if (!nextDriver || typeof nextDriver.begin !== "function") {
+      throw new TypeError("Invalid Grok auth driver")
+    }
+    const token = Object.freeze({})
+    installed = { driver: nextDriver, token }
+    return () => {
+      if (installed?.token === token) installed = undefined
+    }
+  }
+
+  return Object.freeze({
+    installDriver: install,
+
+    async status() {
+      return Object.freeze({
+        ...await registry.status(),
+        driver: installed !== undefined,
+        ...(state === undefined ? {} : { session: Object.freeze({ ...state }) }),
+      })
+    },
+
+    async beginLogin() {
+      if (active !== undefined || closing) throw new AuthLoginBusyError()
+      if (installed === undefined) throw new AuthDriverUnavailableError()
+
+      const sessionId = createId(randomUUID, "Invalid Grok auth session id")
+      const abortController = new AbortController()
+      let started
+      try {
+        started = await installed.driver.begin({ signal: abortController.signal })
+      } catch {
+        state = { state: "failed", sessionId }
+        registry.invalidate()
+        throw new AuthDriverUnavailableError()
+      }
+      if (
+        !isPlainObject(started) ||
+        Object.keys(started).length !== 1 ||
+        !started.completion ||
+        typeof started.completion.then !== "function"
+      ) throw new TypeError("Invalid Grok auth driver session")
+
+      const publicState = Object.freeze({ sessionId, state: "running" })
+      state = publicState
+      const settled = Promise.resolve(started.completion).then(
+        (outcome) => normalizeOutcome(outcome),
+        () => Object.freeze({ kind: abortController.signal.aborted ? "cancelled" : "failed" }),
+      ).then((outcome) => {
+        state = { state: outcome.kind, sessionId }
+        active = undefined
+        registry.invalidate()
+        return outcome
+      })
+
+      const session = Object.freeze({
+        public: publicState,
+        cancel() {
+          abortController.abort()
+        },
+        async wait({ signal } = {}) {
+          if (!signal) return settled
+          if (signal.aborted) {
+            abortController.abort(signal.reason)
+            return settled
+          }
+          const abort = () => abortController.abort(signal.reason)
+          signal.addEventListener("abort", abort, { once: true })
+          try {
+            return await settled
+          } finally {
+            signal.removeEventListener("abort", abort)
+          }
+        },
+      })
+      active = session
+      return session
+    },
+
+    cancel(sessionId) {
+      if (active === undefined || active.public.sessionId !== sessionId) return false
+      active.cancel()
+      return true
+    },
+
+    async shutdown() {
+      if (active === undefined) return false
+      active.cancel()
+      await active.wait()
+      return true
+    },
+
+    async logout({ signal } = {}) {
+      if (closing) throw new AuthLoginBusyError()
+      if (installed === undefined || typeof installed.driver.logout !== "function") {
+        throw new AuthDriverUnavailableError()
+      }
+      const currentTime = now()
+      if (!(currentTime instanceof Date) || !Number.isFinite(currentTime.getTime())) {
+        throw new TypeError("Invalid Grok auth controller clock")
+      }
+      if (confirmation === undefined || confirmation.expiresAt <= currentTime.getTime()) {
+        const confirmationId = createId(randomUUID, "Invalid Grok logout confirmation id")
+        const expiresAt = currentTime.getTime() + 30_000
+        confirmation = { confirmationId, expiresAt }
+        return Object.freeze({
+          kind: "confirmation-required",
+          confirmationId,
+          expiresAt: new Date(expiresAt).toISOString(),
+        })
+      }
+
+      confirmation = undefined
+      closing = true
+      try {
+        if (active !== undefined) {
+          active.cancel()
+          await active.wait()
+        }
+        let outcome
+        try {
+          outcome = normalizeOutcome(await installed.driver.logout({ signal }))
+        } catch {
+          outcome = Object.freeze({ kind: signal?.aborted ? "cancelled" : "failed" })
+        }
+        registry.invalidate()
+        return outcome
+      } finally {
+        closing = false
+      }
+    },
+  })
+}
+
+function normalizeOutcome(outcome) {
+  if (!isPlainObject(outcome) || !OUTCOMES.has(outcome.kind) || Object.keys(outcome).length !== 1) {
+    return Object.freeze({ kind: "failed" })
+  }
+  return Object.freeze({ kind: outcome.kind })
+}
+
+function createId(randomUUID, message) {
+  const value = randomUUID()
+  if (typeof value !== "string" || value.length === 0 || value.length > 128) throw new TypeError(message)
+  return value
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}