@gajae-code/coding-agent 0.4.5 → 0.5.1

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/billing.ts

@@ -0,0 +1,57 @@
+import { getBaseUrl } from '../shared/base-url.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 /login grok-build or set GROK_CLI_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/defaults/gjc/extensions/grok-cli-vendor/src/provider/register.ts

@@ -0,0 +1,99 @@
+/**
+ * GJC Grok Build provider — SuperGrok OAuth + cli-chat-proxy models.
+ */
+
+import type { Api, Model } from '@gajae-code/ai';
+import { Effort } from '@gajae-code/ai/model-thinking';
+import type { OAuthCredentials, OAuthLoginCallbacks } from '@gajae-code/ai/utils/oauth/types';
+import { loginXai, refreshXaiToken, XAI_OAUTH_SCOPE } from '@gajae-code/ai/utils/oauth/xai';
+import type { ExtensionAPI, ProviderConfig } from '@gajae-code/coding-agent';
+import { type GrokCliModelConfig, resolveModels } from '../models/catalog.js';
+import { sanitizePayload } from '../payload/sanitize.js';
+import { getBaseUrl, isGrokBuildBaseUrlOverrideIgnored } from '../shared/base-url.js';
+import { streamGrokCli } from './stream.js';
+import { registerUsageCommand } from './usage.js';
+
+const GROK_BUILD_XAI_AUTHORIZE_PARAMS = {
+  plan: 'generic',
+  referrer: 'gjc-grok-cli',
+} satisfies Readonly<Record<string, string>>;
+
+const GROK_BUILD_XAI_REFRESH_PARAMS = {
+  scope: XAI_OAUTH_SCOPE,
+  ...GROK_BUILD_XAI_AUTHORIZE_PARAMS,
+} satisfies Readonly<Record<string, string>>;
+
+export default function registerGrokCli(api: ExtensionAPI) {
+  const baseUrl = getBaseUrl();
+  const models = resolveModels();
+
+  api.registerProvider('grok-build', {
+    baseUrl,
+    apiKey: process.env.GROK_CLI_OAUTH_TOKEN ? 'GROK_CLI_OAUTH_TOKEN' : undefined,
+    api: 'grok-cli-responses',
+    models: models.map((m: GrokCliModelConfig) => ({
+      id: m.id,
+      name: m.name,
+      reasoning: m.reasoning,
+      thinking: m.reasoning
+        ? { minLevel: Effort.Low, maxLevel: Effort.XHigh, mode: 'effort' }
+        : undefined,
+      input: m.input,
+      cost: m.cost,
+      contextWindow: m.contextWindow,
+      maxTokens: m.maxTokens,
+    })),
+    oauth: {
+      name: 'Grok Build',
+
+      async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+        return loginXai(callbacks, { extraAuthorizeParams: GROK_BUILD_XAI_AUTHORIZE_PARAMS });
+      },
+
+      async refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
+        return refreshXaiToken(credentials.refresh, {
+          extraTokenParams: GROK_BUILD_XAI_REFRESH_PARAMS,
+        });
+      },
+
+      getApiKey(credentials: OAuthCredentials): string {
+        return credentials.access;
+      },
+
+      modifyModels(models: Model<Api>[], _credentials: OAuthCredentials) {
+        const effectiveBaseUrl = getBaseUrl().replace(/\/+$/, '');
+
+        return models.map((m) =>
+          m.provider === 'grok-build' ? { ...m, baseUrl: effectiveBaseUrl } : m,
+        );
+      },
+    } satisfies ProviderConfig['oauth'],
+
+    streamSimple: streamGrokCli,
+  });
+
+  api.on('session_start', (_event, ctx) => {
+    if (process.env.GROK_CLI_OAUTH_TOKEN) {
+      ctx.ui.notify(
+        '[Grok Build] Using GROK_CLI_OAUTH_TOKEN env bypass — no auto-refresh, no model discovery. Login with /login grok-build for persisted refreshable auth.',
+        'warning',
+      );
+    }
+    if (isGrokBuildBaseUrlOverrideIgnored()) {
+      ctx.ui.notify(
+        '[Grok Build] Ignoring unsafe Grok base URL override for OAuth credential safety. Set GJC_GROK_CLI_ALLOW_UNSAFE_BASE_URL=1 only for trusted local testing.',
+        'warning',
+      );
+    }
+  });
+
+  api.on('before_provider_request', (event, ctx) => {
+    if (ctx.model?.provider !== 'grok-build') return;
+
+    const modelId = ctx.model?.id ?? '';
+    const sessionId = ctx.sessionManager?.getSessionId();
+    return sanitizePayload(event.payload as Record<string, unknown>, modelId, sessionId, ctx.cwd);
+  });
+
+  registerUsageCommand(api);
+}

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/stream.ts

@@ -0,0 +1,50 @@
+import type {
+  Api,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  SimpleStreamOptions,
+} from '@gajae-code/ai';
+import { streamOpenAIResponses } from '@gajae-code/ai/providers/openai-responses';
+
+const GROK_CLI_VERSION = '0.2.33';
+
+/**
+ * Stream function that adds Grok CLI-specific headers to requests.
+ *
+ * GJC Grok Build extension sends cli-chat-proxy headers (see agent.models.grok-cli.yml):
+ *   - x-grok-conv-id: <session/conversation ID>
+ *   - x-grok-model-override: <model ID>
+ *   - x-xai-token-auth: xai-grok-cli
+ */
+export function streamGrokCli(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const sessionId = options?.sessionId;
+  const headers: Record<string, string> = {
+    ...options?.headers,
+    'x-grok-client-identifier': 'gjc-grok-cli',
+    'x-grok-client-version': GROK_CLI_VERSION,
+    'x-xai-token-auth': 'xai-grok-cli',
+    'x-grok-model-override': model.id,
+  };
+
+  if (sessionId) {
+    headers['x-grok-conv-id'] = sessionId;
+  }
+
+  const responsesModel = {
+    ...model,
+    api: 'openai-responses',
+  } as Model<'openai-responses'>;
+
+  return streamOpenAIResponses(responsesModel, context, {
+    ...options,
+    headers,
+    onResponse(response) {
+      options?.onResponse?.(response, model);
+    },
+  });
+}

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/usage.ts

@@ -0,0 +1,56 @@
+import type { Api, Model } from '@gajae-code/ai';
+import type { ExtensionAPI } from '@gajae-code/coding-agent';
+import { XaiOAuthError } from '../shared/errors.js';
+import { fetchBillingUsage, formatQuota } from './billing.js';
+
+export function registerUsageCommand(api: Pick<ExtensionAPI, 'registerCommand'>) {
+  api.registerCommand('grok-build-usage', {
+    description: 'Show Grok Build provider status, quota, and token health',
+    handler: async (_args, ctx) => {
+      const token = process.env.GROK_CLI_OAUTH_TOKEN;
+      if (token) {
+        ctx.ui.notify(
+          '⚠️  Grok Build: using GROK_CLI_OAUTH_TOKEN env bypass — no auto-refresh available',
+          'warning',
+        );
+      }
+
+      try {
+        const registry = ctx.modelRegistry;
+        const grokModels = registry.getAll().filter((m: Model<Api>) => m.provider === 'grok-build');
+        if (grokModels.length === 0) {
+          ctx.ui.notify(
+            'Grok Build: no models registered. Run /login grok-build first.',
+            'warning',
+          );
+          return;
+        }
+
+        const apiKey = token ?? (await registry.getApiKeyForProvider?.('grok-build'));
+        if (!apiKey) {
+          ctx.ui.notify(formatQuota(undefined).join('\n'), 'info');
+          return;
+        }
+
+        try {
+          ctx.ui.notify('Fetching grok build usage…', 'info');
+          ctx.ui.notify(formatQuota(await fetchBillingUsage(apiKey)).join('\n'), 'info');
+        } catch (err) {
+          ctx.ui.notify(
+            `Grok Build billing refresh failed: ${err instanceof Error ? err.message : String(err)}`,
+            'warning',
+          );
+          ctx.ui.notify(formatQuota(undefined).join('\n'), 'info');
+        }
+      } catch (err) {
+        const msg =
+          err instanceof XaiOAuthError
+            ? `${err.message} (code: ${err.code})`
+            : err instanceof Error
+              ? err.message
+              : String(err);
+        ctx.ui.notify(`Grok Build: ${msg}`, 'warning');
+      }
+    },
+  });
+}

package/src/defaults/gjc/extensions/grok-cli-vendor/src/shared/base-url.ts

@@ -0,0 +1,36 @@
+const DEFAULT_GROK_BUILD_BASE_URL = 'https://cli-chat-proxy.grok.com/v1';
+const ALLOWED_GROK_BUILD_HOSTS = new Set(['cli-chat-proxy.grok.com']);
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.trim().replace(/\/+$/, '');
+}
+
+function isAllowedCredentialHost(baseUrl: string): boolean {
+  try {
+    const url = new URL(baseUrl);
+    return url.protocol === 'https:' && ALLOWED_GROK_BUILD_HOSTS.has(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+export function getBaseUrl(): string {
+  const configured = process.env.GJC_GROK_CLI_BASE_URL || process.env.GROK_CLI_BASE_URL;
+  if (!configured) return DEFAULT_GROK_BUILD_BASE_URL;
+
+  const normalized = normalizeBaseUrl(configured);
+  if (isAllowedCredentialHost(normalized)) return normalized;
+
+  if (process.env.GJC_GROK_CLI_ALLOW_UNSAFE_BASE_URL === '1') return normalized;
+
+  return DEFAULT_GROK_BUILD_BASE_URL;
+}
+
+export function isGrokBuildBaseUrlOverrideIgnored(): boolean {
+  const configured = process.env.GJC_GROK_CLI_BASE_URL || process.env.GROK_CLI_BASE_URL;
+  if (!configured) return false;
+  const normalized = normalizeBaseUrl(configured);
+  return (
+    !isAllowedCredentialHost(normalized) && process.env.GJC_GROK_CLI_ALLOW_UNSAFE_BASE_URL !== '1'
+  );
+}

package/src/defaults/gjc/extensions/grok-cli-vendor/src/shared/errors.ts

@@ -0,0 +1,44 @@
+/**
+ * Typed error for xAI OAuth failures.
+ *
+ * Codes allow the login flow and stream handlers to distinguish
+ * retryable failures (network) from fatal ones (revoked refresh token).
+ */
+export class XaiOAuthError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly reloginRequired = false,
+  ) {
+    super(message);
+    this.name = 'XaiOAuthError';
+  }
+}
+
+/** Well-known error codes. */
+export const XaiErrorCode = {
+  /** OIDC discovery failed (network, invalid response). */
+  DISCOVERY_FAILED: 'discovery_failed',
+  /** Discovery endpoint returned a non-xAI origin. */
+  DISCOVERY_INVALID_ORIGIN: 'discovery_invalid_origin',
+  /** Authorization was denied or errored in the browser. */
+  AUTHORIZATION_FAILED: 'authorization_failed',
+  /** CSRF state mismatch between request and callback. */
+  STATE_MISMATCH: 'state_mismatch',
+  /** Callback did not include an authorization code. */
+  CODE_MISSING: 'code_missing',
+  /** Token exchange failed (network, invalid response). */
+  TOKEN_EXCHANGE_FAILED: 'token_exchange_failed',
+  /** Token exchange returned an invalid payload. */
+  TOKEN_EXCHANGE_INVALID: 'token_exchange_invalid',
+  /** Refresh token is missing or empty. */
+  REFRESH_MISSING: 'refresh_missing',
+  /** Token refresh failed (expired, revoked). */
+  REFRESH_FAILED: 'refresh_failed',
+  /** No credentials stored. */
+  AUTH_MISSING: 'auth_missing',
+  /** Loopback callback server could not bind. */
+  CALLBACK_BIND_FAILED: 'callback_bind_failed',
+  /** Loopback callback timed out. */
+  CALLBACK_TIMEOUT: 'callback_timeout',
+} as const;