open-grok-build 0.1.0

package/src/opencode/billing.ts

@@ -0,0 +1,57 @@
+import { getBaseUrl } from '../auth/oauth.js';
+
+interface BillingUsage {
+  monthlyLimit: number;
+  used: number;
+  billingPeriodEnd: string;
+}
+
+function parseBillingUsage(payload: unknown): BillingUsage {
+  if (!payload || typeof payload !== 'object') throw new Error('invalid billing payload');
+  const config = (payload as Record<string, unknown>).config;
+  if (!config || typeof config !== 'object') throw new Error('invalid billing payload');
+  const monthlyLimit = ((config as Record<string, unknown>).monthlyLimit as Record<string, unknown>)
+    ?.val;
+  const used = ((config as Record<string, unknown>).used as Record<string, unknown>)?.val;
+  const billingPeriodEnd = (config as Record<string, unknown>).billingPeriodEnd;
+  if (
+    typeof monthlyLimit !== 'number' ||
+    !Number.isFinite(monthlyLimit) ||
+    typeof used !== 'number' ||
+    !Number.isFinite(used) ||
+    typeof billingPeriodEnd !== 'string' ||
+    !Number.isFinite(new Date(billingPeriodEnd).getTime())
+  ) {
+    throw new Error('invalid billing payload');
+  }
+  return { monthlyLimit, used, billingPeriodEnd };
+}
+
+export async function fetchBillingUsage(token: string): Promise<BillingUsage> {
+  const response = await fetch(`${getBaseUrl()}/billing`, {
+    headers: {
+      authorization: `Bearer ${token}`,
+      'x-xai-token-auth': 'xai-grok-cli',
+      accept: 'application/json',
+    },
+  });
+  if (!response.ok) throw new Error(`billing endpoint returned ${response.status}`);
+  return parseBillingUsage(await response.json());
+}
+
+export function formatQuota(usage: BillingUsage | undefined) {
+  if (!usage) {
+    return [
+      '  Usage:',
+      '    no billing data available — run /connect grok-build or set GROK_BUILD_OAUTH_TOKEN',
+    ];
+  }
+
+  const resetDate = new Date(new Date(usage.billingPeriodEnd).getTime() - 8 * 60 * 60 * 1000);
+  return [
+    '  Usage:',
+    `    ${usage.used.toLocaleString()} / ${usage.monthlyLimit.toLocaleString()} credits used (${Math.round((usage.used / usage.monthlyLimit) * 100)}%)`,
+    `    ${(usage.monthlyLimit - usage.used).toLocaleString()} credits remaining`,
+    `    Resets at ${['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][resetDate.getUTCMonth()]} ${resetDate.getUTCDate()} ${resetDate.getUTCHours().toString().padStart(2, '0')}:${resetDate.getUTCMinutes().toString().padStart(2, '0')} PT`,
+  ];
+}

package/src/opencode/collectGrokTools.ts

@@ -0,0 +1,18 @@
+import { registerGrokTools } from '../tools/register.js';
+import type { ShimRegisteredTool } from '../tools/types.js';
+
+export type CollectedGrokTool = Pick<ShimRegisteredTool, 'name' | 'description' | 'execute'>;
+
+export function collectGrokShimTools(): CollectedGrokTool[] {
+  const tools: CollectedGrokTool[] = [];
+  registerGrokTools({
+    registerTool(tool) {
+      tools.push({
+        name: tool.name,
+        description: tool.description,
+        execute: tool.execute,
+      });
+    },
+  });
+  return tools;
+}

package/src/opencode/grokModels.ts

@@ -0,0 +1,72 @@
+// @ts-nocheck — catalog fields extend SDK Model shape for grok-build provider config.
+import type { Model as ModelV2 } from '@opencode-ai/sdk/v2';
+import { type GrokBuildModelConfig, resolveModels } from '../models/catalog.js';
+
+export const GROK_BUILD_PROVIDER_ID = 'grok-build';
+
+export function grokBuildProviderConfig() {
+  const models = resolveModels();
+  return {
+    name: 'Grok Build',
+    npm: '@ai-sdk/openai-compatible',
+    api: 'https://cli-chat-proxy.grok.com/v1',
+    models: Object.fromEntries(
+      models.map((m) => [
+        m.id,
+        {
+          name: m.name,
+          reasoning: m.reasoning,
+          modalities: { input: m.input },
+          cost: {
+            input: m.cost.input,
+            output: m.cost.output,
+            cache: { read: m.cost.cacheRead, write: m.cost.cacheWrite },
+          },
+          limit: {
+            context: m.contextWindow,
+            output: m.maxTokens,
+          },
+        },
+      ]),
+    ),
+  };
+}
+
+export function toPluginModels(
+  providerModels: Record<string, ModelV2>,
+  catalog: GrokBuildModelConfig[],
+): Record<string, ModelV2> {
+  const byId = new Map(catalog.map((m) => [m.id, m]));
+  const result: Record<string, ModelV2> = {};
+
+  for (const [modelID, model] of Object.entries(providerModels)) {
+    const entry = byId.get(modelID);
+    if (!entry) {
+      result[modelID] = model;
+      continue;
+    }
+    result[modelID] = {
+      ...model,
+      name: entry.name,
+      reasoning: entry.reasoning,
+      modalities: { input: entry.input },
+      cost: {
+        input: entry.cost.input,
+        output: entry.cost.output,
+        cache: { read: entry.cost.cacheRead, write: entry.cost.cacheWrite },
+      },
+      limit: {
+        context: entry.contextWindow,
+        output: entry.maxTokens,
+      },
+    };
+  }
+
+  for (const entry of catalog) {
+    if (!result[entry.id]) {
+      result[entry.id] = providerModels[entry.id] ?? ({} as ModelV2);
+    }
+  }
+
+  return result;
+}

package/src/opencode/grokToolSchemas.ts

@@ -0,0 +1,88 @@
+import { tool } from '@opencode-ai/plugin/tool';
+
+/** Zod arg schemas for Cursor/Grok shim tools (execute logic from registerGrokTools). */
+export const grokToolArgSchemas: Record<string, Record<string, unknown>> = {
+  Grep: {
+    pattern: tool.schema.string().describe('Regex pattern to search for in file contents'),
+    path: tool.schema
+      .string()
+      .optional()
+      .describe('Directory or file to search. Defaults to current working directory.'),
+    include: tool.schema
+      .string()
+      .optional()
+      .describe('Glob pattern to filter which files are searched (e.g. *.ts, **/*.md)'),
+  },
+  Glob: {
+    pattern: tool.schema
+      .string()
+      .describe('Glob pattern to match files (e.g. **/*.ts, src/**/*.json)'),
+    path: tool.schema
+      .string()
+      .optional()
+      .describe('Directory to search within. Defaults to current working directory.'),
+  },
+  LS: {
+    path: tool.schema.string().describe('Directory path to list'),
+  },
+  Read: {
+    path: tool.schema.string().describe('Path to the file to read'),
+    offset: tool.schema
+      .number()
+      .optional()
+      .describe('Line number to start reading from (0-indexed)'),
+    limit: tool.schema.number().optional().describe('Maximum number of lines to read'),
+  },
+  Write: {
+    path: tool.schema.string().describe('Path to the file to write'),
+    content: tool.schema.string().describe('Content to write to the file'),
+  },
+  StrReplace: {
+    path: tool.schema.string().describe('Path to the file to modify'),
+    old_str: tool.schema.string().describe('String to search for (exact match)'),
+    new_str: tool.schema.string().describe('String to replace with'),
+  },
+  Edit: {
+    path: tool.schema.string().describe('Path to the file to modify'),
+    edits: tool.schema
+      .array(
+        tool.schema.object({
+          oldText: tool.schema.string(),
+          newText: tool.schema.string(),
+        }),
+      )
+      .optional()
+      .describe('Exact text replacements to apply sequentially'),
+    applyPatch: tool.schema
+      .object({ patchContent: tool.schema.string() })
+      .optional()
+      .describe('Unsupported unified patch content'),
+    strReplace: tool.schema
+      .object({
+        oldText: tool.schema.string(),
+        newText: tool.schema.string(),
+      })
+      .optional(),
+    multiStrReplace: tool.schema
+      .object({
+        edits: tool.schema.array(
+          tool.schema.object({
+            oldText: tool.schema.string(),
+            newText: tool.schema.string(),
+          }),
+        ),
+      })
+      .optional(),
+  },
+  Delete: {
+    path: tool.schema.string().describe('Path to the file to delete'),
+  },
+  Shell: {
+    command: tool.schema.string().describe('Shell command to execute'),
+    working_directory: tool.schema
+      .string()
+      .optional()
+      .describe('Working directory for the command'),
+    timeout: tool.schema.number().optional().describe('Timeout in milliseconds (default: 120000)'),
+  },
+} as const;

package/src/opencode/plugin.ts

@@ -0,0 +1,227 @@
+// @ts-nocheck — OpenCode config/auth hook payloads are loosely typed at the host boundary.
+import type { Hooks, Plugin, PluginInput } from '@opencode-ai/plugin';
+import { tool } from '@opencode-ai/plugin/tool';
+import * as oauth from '../auth/oauth.js';
+import { resolveModels } from '../models/catalog.js';
+import { sanitizePayload } from '../payload/sanitize.js';
+import { collectGrokShimTools } from './collectGrokTools.js';
+import { GROK_BUILD_PROVIDER_ID, grokBuildProviderConfig, toPluginModels } from './grokModels.js';
+import { grokToolArgSchemas } from './grokToolSchemas.js';
+
+import { OPENCODE_INSTALLATION_VERSION } from './version.js';
+
+const GROK_BUILD_VERSION = '0.2.16';
+const OAUTH_DUMMY_KEY = 'opencode-oauth-dummy-key';
+const ACCESS_TOKEN_REFRESH_SKEW_MS = 120_000;
+
+const collectedTools = collectGrokShimTools();
+
+function accessTokenIsExpiring(
+  token: string | undefined,
+  skewMs = ACCESS_TOKEN_REFRESH_SKEW_MS,
+): boolean {
+  if (!token || typeof token !== 'string') return false;
+  const parts = token.split('.');
+  if (parts.length < 2) return false;
+  try {
+    let payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+    while (payload.length % 4 !== 0) payload += '=';
+    const claims = JSON.parse(Buffer.from(payload, 'base64').toString('utf8'));
+    if (typeof claims?.exp !== 'number') return false;
+    return claims.exp * 1000 <= Date.now() + Math.max(0, skewMs);
+  } catch {
+    return false;
+  }
+}
+
+function isGrokBuildModel(model: { providerID: string }) {
+  return model.providerID === GROK_BUILD_PROVIDER_ID;
+}
+
+function buildGrokToolDefinitions() {
+  const defs: NonNullable<Hooks['tool']> = {};
+  for (const entry of collectedTools) {
+    const args = grokToolArgSchemas[entry.name as keyof typeof grokToolArgSchemas];
+    if (!args) continue;
+    defs[entry.name] = tool({
+      description: entry.description,
+      args,
+      async execute(params, ctx) {
+        const result = await entry.execute(
+          'opencode',
+          params as Record<string, unknown>,
+          ctx.abort,
+          undefined,
+          { cwd: ctx.directory },
+        );
+        const text = result.content
+          .filter((part) => part.type === 'text')
+          .map((part) => part.text)
+          .join('\n');
+        return {
+          title: entry.name,
+          output: text,
+          metadata: result.details ?? {},
+        };
+      },
+    });
+  }
+  return defs;
+}
+
+export const OpenGrokBuildPlugin: Plugin = async (input: PluginInput) => {
+  return {
+    config: async (cfg) => {
+      const existing = cfg.provider?.[GROK_BUILD_PROVIDER_ID];
+      if (!existing) {
+        if (!cfg.provider) cfg.provider = {};
+        cfg.provider[GROK_BUILD_PROVIDER_ID] = grokBuildProviderConfig();
+      }
+    },
+
+    provider: {
+      id: GROK_BUILD_PROVIDER_ID,
+      async models(provider, _ctx) {
+        return toPluginModels(provider.models, resolveModels());
+      },
+    },
+
+    auth: {
+      provider: GROK_BUILD_PROVIDER_ID,
+      async loader(getAuth) {
+        const auth = await getAuth();
+        if (auth.type !== 'oauth') return {};
+
+        let refreshPromise:
+          | Promise<{ access: string; refresh: string; expires: number }>
+          | undefined;
+
+        return {
+          apiKey: OAUTH_DUMMY_KEY,
+          async fetch(requestInput: RequestInfo | URL, init?: RequestInit) {
+            let currentAuth = await getAuth();
+            if (currentAuth.type !== 'oauth') return fetch(requestInput, init);
+
+            const expiresSoon =
+              !currentAuth.expires ||
+              currentAuth.expires - Date.now() <= ACCESS_TOKEN_REFRESH_SKEW_MS ||
+              accessTokenIsExpiring(currentAuth.access);
+
+            if (expiresSoon) {
+              if (!refreshPromise) {
+                const refreshToken = currentAuth.refresh;
+                refreshPromise = oauth
+                  .refresh({
+                    access: currentAuth.access,
+                    refresh: refreshToken,
+                    expires: currentAuth.expires ?? 0,
+                  })
+                  .then(async (tokens) => {
+                    const expires = tokens.expires;
+                    await input.client.auth
+                      .set({
+                        path: { id: GROK_BUILD_PROVIDER_ID },
+                        body: {
+                          type: 'oauth',
+                          access: tokens.access,
+                          refresh: tokens.refresh,
+                          expires,
+                        },
+                      })
+                      .catch(() => undefined);
+                    return {
+                      access: tokens.access,
+                      refresh: tokens.refresh,
+                      expires,
+                    };
+                  })
+                  .finally(() => {
+                    refreshPromise = undefined;
+                  });
+              }
+              const refreshed = await refreshPromise;
+              currentAuth = { ...currentAuth, ...refreshed };
+            }
+
+            const headers = new Headers(
+              requestInput instanceof Request ? requestInput.headers : undefined,
+            );
+            if (init?.headers) {
+              const entries =
+                init.headers instanceof Headers
+                  ? init.headers.entries()
+                  : Array.isArray(init.headers)
+                    ? init.headers
+                    : Object.entries(init.headers as Record<string, string | undefined>);
+              for (const [key, value] of entries) {
+                if (value !== undefined) headers.set(key, String(value));
+              }
+            }
+            headers.set('authorization', `Bearer ${currentAuth.access}`);
+            headers.set('x-grok-client-identifier', 'grok-shell');
+            headers.set('x-grok-client-version', GROK_BUILD_VERSION);
+            headers.set('x-xai-token-auth', 'xai-grok-cli');
+            headers.set('User-Agent', `opencode/${OPENCODE_INSTALLATION_VERSION}`);
+
+            return fetch(requestInput, { ...init, headers });
+          },
+        };
+      },
+      methods: [
+        {
+          label: 'Grok Build (cli-chat-proxy)',
+          type: 'oauth',
+          authorize: async () => {
+            const session = await oauth.beginGrokBuildOAuth('open-grok-build');
+            return {
+              url: session.url,
+              instructions: session.instructions,
+              method: 'auto' as const,
+              callback: async () => {
+                try {
+                  const credentials = await session.finish();
+                  return {
+                    type: 'success' as const,
+                    refresh: credentials.refresh,
+                    access: credentials.access,
+                    expires: credentials.expires,
+                  };
+                } catch {
+                  return { type: 'failed' as const };
+                }
+              },
+            };
+          },
+        },
+        {
+          label: 'Grok Build token bypass (GROK_BUILD_OAUTH_TOKEN)',
+          type: 'api',
+        },
+      ],
+    },
+
+    'chat.headers': async (chatInput, output) => {
+      if (!isGrokBuildModel(chatInput.model)) return;
+      output.headers['x-grok-client-identifier'] = 'open-grok-build';
+      output.headers['x-grok-client-version'] = GROK_BUILD_VERSION;
+      output.headers['x-xai-token-auth'] = 'xai-grok-cli';
+      output.headers['x-grok-model-override'] = chatInput.model.id;
+      output.headers['x-grok-conv-id'] = chatInput.sessionID;
+      output.headers['User-Agent'] = `opencode/${OPENCODE_INSTALLATION_VERSION}`;
+    },
+
+    'chat.params': async (chatInput, output) => {
+      if (!isGrokBuildModel(chatInput.model)) return;
+      const cwd = input.directory;
+      const sanitized = sanitizePayload(
+        { ...output.options },
+        chatInput.model.id,
+        chatInput.sessionID,
+        cwd,
+      );
+      output.options = { ...output.options, ...sanitized };
+    },
+
+    tool: buildGrokToolDefinitions(),
+  };
+};

package/src/opencode/tui.tsx

@@ -0,0 +1,64 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginModule } from '@opencode-ai/plugin/tui';
+import { buildGrokBuildUsageReport } from './usage.js';
+import {
+  formatUsageToastMessage,
+  GROK_BUILD_USAGE_SLASH,
+  GROK_BUILD_USAGE_TUI_COMMAND,
+} from './usageToast.js';
+
+async function showUsageToast(api: {
+  ui: {
+    toast: (input: {
+      variant?: 'info' | 'success' | 'warning' | 'error';
+      title?: string;
+      message: string;
+      duration?: number;
+    }) => void;
+  };
+}) {
+  const report = await buildGrokBuildUsageReport();
+  api.ui.toast({
+    variant: 'info',
+    title: 'Grok Build',
+    message: formatUsageToastMessage(report),
+    duration: 8_000,
+  });
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+  id: 'open-grok-build.tui',
+  async tui(api) {
+    api.keymap.registerLayer({
+      commands: [
+        {
+          name: GROK_BUILD_USAGE_TUI_COMMAND,
+          title: 'Grok Build usage',
+          description: 'Show Grok Build billing quota and token health',
+          category: 'Grok Build',
+          namespace: 'palette',
+          slashName: GROK_BUILD_USAGE_SLASH,
+          async run() {
+            await showUsageToast(api);
+          },
+        },
+      ],
+    });
+
+    api.command?.register?.(() => [
+      {
+        title: 'Grok Build usage',
+        value: GROK_BUILD_USAGE_TUI_COMMAND,
+        description: 'Show Grok Build billing quota and token health',
+        category: 'Grok Build',
+        slash: { name: GROK_BUILD_USAGE_SLASH },
+        async onSelect() {
+          api.ui.dialog.clear();
+          await showUsageToast(api);
+        },
+      },
+    ]);
+  },
+};
+
+export default plugin;

package/src/opencode/usage.ts

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fetchBillingUsage, formatQuota } from './billing.js';
+import { GROK_BUILD_PROVIDER_ID } from './grokModels.js';
+
+export const GROK_BUILD_USAGE_COMMAND = 'grok-build-usage';
+
+export const GROK_BUILD_USAGE_DESCRIPTION =
+  'Show Grok Build provider status, billing quota, and token health';
+
+type StoredAuth = {
+  type?: string;
+  access?: string;
+  key?: string;
+};
+
+function opencodeAuthPath() {
+  return join(homedir(), '.local', 'share', 'opencode', 'auth.json');
+}
+
+function readOpencodeAuthFile(): Record<string, StoredAuth> {
+  const path = opencodeAuthPath();
+  if (!existsSync(path)) return {};
+  try {
+    const payload = JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+    if (!payload || typeof payload !== 'object') return {};
+    return payload as Record<string, StoredAuth>;
+  } catch {
+    return {};
+  }
+}
+
+function readOpencodeAuthFromEnv(): Record<string, StoredAuth> {
+  const raw = process.env.OPENCODE_AUTH_CONTENT;
+  if (!raw) return {};
+  try {
+    const payload = JSON.parse(raw) as Record<string, unknown>;
+    if (!payload || typeof payload !== 'object') return {};
+    return payload as Record<string, StoredAuth>;
+  } catch {
+    return {};
+  }
+}
+
+export function resolveGrokBuildAccessToken(): string | undefined {
+  const envToken = process.env.GROK_BUILD_OAUTH_TOKEN;
+  if (envToken) return envToken;
+
+  const auth = { ...readOpencodeAuthFile(), ...readOpencodeAuthFromEnv() };
+  const entry = auth[GROK_BUILD_PROVIDER_ID];
+  if (!entry || typeof entry !== 'object') return undefined;
+  if (entry.type === 'oauth' && typeof entry.access === 'string' && entry.access) {
+    return entry.access;
+  }
+  if (entry.type === 'api' && typeof entry.key === 'string' && entry.key) return entry.key;
+  return undefined;
+}
+
+export async function buildGrokBuildUsageReport(): Promise<string[]> {
+  const lines: string[] = [];
+
+  if (process.env.GROK_BUILD_OAUTH_TOKEN) {
+    lines.push('  ⚠️  Using GROK_BUILD_OAUTH_TOKEN env bypass — no auto-refresh available');
+  }
+
+  const token = resolveGrokBuildAccessToken();
+  if (!token) {
+    lines.push(...formatQuota(undefined));
+    return lines;
+  }
+
+  try {
+    lines.push(...formatQuota(await fetchBillingUsage(token)));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    lines.push(`  billing refresh failed: ${message}`);
+    lines.push(...formatQuota(undefined));
+  }
+
+  return lines;
+}

package/src/opencode/usageToast.ts

@@ -0,0 +1,9 @@
+import { GROK_BUILD_USAGE_COMMAND } from './usage.js';
+
+export function formatUsageToastMessage(report: string[]): string {
+  return report.join('\n');
+}
+
+export const GROK_BUILD_USAGE_TUI_COMMAND = 'open-grok-build.grok-build-usage';
+
+export const GROK_BUILD_USAGE_SLASH = GROK_BUILD_USAGE_COMMAND;

package/src/opencode/version.ts

@@ -0,0 +1,2 @@
+/** Matches opencode InstallationVersion when running inside OpenCode. */
+export const OPENCODE_INSTALLATION_VERSION = 'open-grok-build';