@bitkyc08/opencodex 2.52.0-preview.20260911 → 2.52.0

package/src/grok/grpc-web.ts

@@ -0,0 +1,120 @@
+/**
+ * Minimal, zero-dependency gRPC-Web binary framing encoder and decoder.
+ * Supports 5-byte header prefix: 0x00 data frames, 0x80 trailer frames.
+ */
+
+export interface GrpcWebTrailer {
+  status: number;
+  statusMessage?: string;
+  metadata: Record<string, string>;
+}
+
+export interface DecodedGrpcWebResponse {
+  messages: Uint8Array[];
+  status: number;
+  statusMessage?: string;
+  trailers?: GrpcWebTrailer;
+}
+
+export class GrpcWebError extends Error {
+  readonly status: number;
+  readonly statusMessage: string;
+
+  constructor(status: number, statusMessage: string) {
+    super(`gRPC-Web call failed with status ${status}: ${statusMessage}`);
+    this.name = "GrpcWebError";
+    this.status = status;
+    this.statusMessage = statusMessage;
+  }
+}
+
+const FRAME_DATA = 0x00;
+const FRAME_TRAILER = 0x80;
+const HEADER_SIZE = 5;
+
+/**
+ * Encodes a protobuf payload into a single gRPC-Web binary data frame (flag 0x00).
+ */
+export function encodeGrpcWebEnvelope(message: Uint8Array): Uint8Array {
+  const envelope = new Uint8Array(HEADER_SIZE + message.length);
+  envelope[0] = FRAME_DATA;
+  const view = new DataView(envelope.buffer, envelope.byteOffset, envelope.byteLength);
+  view.setUint32(1, message.length, false); // Big-endian u32
+  envelope.set(message, HEADER_SIZE);
+  return envelope;
+}
+
+/**
+ * Parses ASCII key-value lines from a gRPC-Web trailer frame payload.
+ */
+export function parseGrpcWebTrailers(bytes: Uint8Array): GrpcWebTrailer {
+  const text = new TextDecoder("utf-8").decode(bytes);
+  const lines = text.split(/\r?\n/);
+  const metadata: Record<string, string> = {};
+  let status = 0;
+  let statusMessage: string | undefined;
+
+  for (const line of lines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim().toLowerCase();
+    const value = line.slice(colonIdx + 1).trim();
+    if (!key) continue;
+    metadata[key] = value;
+    if (key === "grpc-status") {
+      const parsed = parseInt(value, 10);
+      if (!Number.isNaN(parsed)) {
+        status = parsed;
+      }
+    } else if (key === "grpc-message") {
+      try {
+        statusMessage = decodeURIComponent(value);
+      } catch {
+        statusMessage = value;
+      }
+    }
+  }
+
+  return { status, statusMessage, metadata };
+}
+
+/**
+ * Decodes a contiguous gRPC-Web binary stream into data messages and trailing metadata.
+ */
+export function decodeGrpcWebResponse(bytes: Uint8Array): DecodedGrpcWebResponse {
+  const messages: Uint8Array[] = [];
+  let offset = 0;
+  let trailer: GrpcWebTrailer | undefined;
+
+  while (offset + HEADER_SIZE <= bytes.length) {
+    const flag = bytes[offset];
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, HEADER_SIZE);
+    const length = view.getUint32(1, false);
+    const frameStart = offset + HEADER_SIZE;
+    const frameEnd = frameStart + length;
+
+    if (frameEnd > bytes.length) {
+      throw new Error(`Incomplete gRPC-Web frame at offset ${offset}: expected ${length} bytes, got ${bytes.length - frameStart}`);
+    }
+
+    const payload = bytes.subarray(frameStart, frameEnd);
+
+    if (flag === FRAME_DATA) {
+      messages.push(payload);
+    } else if (flag === FRAME_TRAILER) {
+      trailer = parseGrpcWebTrailers(payload);
+    }
+
+    offset = frameEnd;
+  }
+
+  const finalStatus = trailer ? trailer.status : 0;
+  const finalMessage = trailer?.statusMessage;
+
+  return {
+    messages,
+    status: finalStatus,
+    statusMessage: finalMessage,
+    trailers: trailer,
+  };
+}

package/src/grok/reset-coupon-ledger.ts

@@ -0,0 +1,139 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFile } from "../config/atomic-write";
+import { getConfigDir } from "../config/paths";
+
+export type GrokResetCouponOperationKind = "execute" | "replay" | "identity-mismatch" | "capacity";
+
+export interface GrokResetCouponOperationIdentity {
+  accountId: string;
+  tokenId?: string;
+  operationId: string;
+}
+
+export interface GrokResetCouponOperationRecord {
+  kind: GrokResetCouponOperationKind;
+  operationId: string;
+  accountId?: string;
+  tokenId?: string;
+  code?: string;
+  settledAt?: number;
+}
+
+interface GrokResetCouponOperationState {
+  accountId: string;
+  tokenId?: string;
+  status: "open" | "settled" | "failed";
+  code?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+interface GrokResetCouponLedger {
+  version: 1;
+  operations: Record<string, GrokResetCouponOperationState>;
+}
+
+export function grokCouponJournalPath(customDir?: string): string {
+  const dir = customDir ?? getConfigDir();
+  return join(dir, "grok-reset-coupon-ledger.json");
+}
+
+function readGrokCouponLedger(filePath: string): GrokResetCouponLedger {
+  if (!existsSync(filePath)) {
+    return { version: 1, operations: {} };
+  }
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw) as GrokResetCouponLedger;
+    return parsed && parsed.version === 1 && parsed.operations && typeof parsed.operations === "object"
+      ? parsed
+      : { version: 1, operations: {} };
+  } catch {
+    return { version: 1, operations: {} };
+  }
+}
+
+function writeGrokCouponLedger(filePath: string, ledger: GrokResetCouponLedger, now = Date.now()): void {
+  // Prune settled/failed operations older than 30 days to avoid unbounded growth
+  const retentionCutoff = now - 30 * 24 * 60 * 60_000;
+  ledger.operations = Object.fromEntries(
+    Object.entries(ledger.operations).filter(
+      ([, op]) => op.status === "open" || op.updatedAt > retentionCutoff,
+    ),
+  );
+  atomicWriteFile(filePath, JSON.stringify(ledger, null, 2));
+}
+
+const MAX_GROK_RESET_COUPON_OPERATION_IDS = 256;
+
+export function openGrokResetCouponOperation(
+  identity: GrokResetCouponOperationIdentity,
+  now = Date.now(),
+  journalPath?: string,
+): GrokResetCouponOperationRecord {
+  const filePath = journalPath ?? grokCouponJournalPath();
+  const ledger = readGrokCouponLedger(filePath);
+
+  if (Object.keys(ledger.operations).length >= MAX_GROK_RESET_COUPON_OPERATION_IDS) {
+    return { kind: "capacity", operationId: identity.operationId };
+  }
+
+  const existing = ledger.operations[identity.operationId];
+  if (existing) {
+    if (existing.accountId !== identity.accountId) {
+      return { kind: "identity-mismatch", operationId: identity.operationId };
+    }
+    if (existing.status !== "open") {
+      // Durably settled already: replay the recorded outcome instead of
+      // trusting upstream idempotency for an irreversible spend.
+      return {
+        kind: "replay",
+        operationId: identity.operationId,
+        accountId: existing.accountId,
+        tokenId: existing.tokenId,
+        code: existing.code,
+        settledAt: existing.updatedAt,
+      };
+    }
+    return {
+      kind: "execute",
+      operationId: identity.operationId,
+      accountId: existing.accountId,
+      tokenId: existing.tokenId,
+    };
+  }
+
+  ledger.operations[identity.operationId] = {
+    accountId: identity.accountId,
+    ...(identity.tokenId === undefined ? {} : { tokenId: identity.tokenId }),
+    status: "open",
+    createdAt: now,
+    updatedAt: now,
+  };
+  writeGrokCouponLedger(filePath, ledger, now);
+  return {
+    kind: "execute",
+    operationId: identity.operationId,
+    accountId: identity.accountId,
+    tokenId: identity.tokenId,
+  };
+}
+
+export function recordGrokResetCouponSettlement(
+  settlement: { operationId: string; tokenId?: string; code: string; status: "success" | "failed" },
+  now = Date.now(),
+  journalPath?: string,
+): void {
+  const filePath = journalPath ?? grokCouponJournalPath();
+  const ledger = readGrokCouponLedger(filePath);
+  const existing = ledger.operations[settlement.operationId];
+  if (!existing) return;
+
+  existing.status = settlement.status === "success" ? "settled" : "failed";
+  existing.code = settlement.code;
+  if (settlement.tokenId !== undefined) existing.tokenId = settlement.tokenId;
+  existing.updatedAt = now;
+
+  writeGrokCouponLedger(filePath, ledger, now);
+}

package/src/grok/reset-coupons.ts

@@ -0,0 +1,278 @@
+import { XAI_GROK_COMPATIBILITY } from "../providers/xai-transport";
+import {
+  decodeGrpcWebResponse,
+  encodeGrpcWebEnvelope,
+  GrpcWebError,
+} from "./grpc-web";
+
+export const GROK_CONSUMER_UI_BASE_URL = "https://grok.com";
+export const GROK_GET_REMAINING_RESETS_ENDPOINT =
+  "https://grok.com/prod_mc_billing.ConsumerUiSvc/GetRemainingResets";
+export const GROK_REDEEM_RESET_ENDPOINT =
+  "https://grok.com/prod_mc_billing.ConsumerUiSvc/RedeemReset";
+
+export interface GrokResetCoupon {
+  tokenId: string;
+  validityStart: string;
+  validityEnd: string;
+}
+
+export interface GetRemainingResetsOptions {
+  accessToken: string;
+  fetchFn?: typeof globalThis.fetch;
+  signal?: AbortSignal;
+  endpoint?: string;
+}
+
+export interface RedeemResetOptions {
+  accessToken: string;
+  tokenId: string;
+  fetchFn?: typeof globalThis.fetch;
+  signal?: AbortSignal;
+  endpoint?: string;
+}
+
+export interface RedeemResetResult {
+  success: boolean;
+  status: number;
+  statusMessage?: string;
+}
+
+/**
+ * Encodes a 32/64-bit non-negative integer into protobuf varint wire bytes.
+ */
+export function encodeVarint(value: number | bigint): Uint8Array {
+  const bytes: number[] = [];
+  let val = BigInt(value);
+  while (val >= 0x80n) {
+    bytes.push(Number((val & 0x7fn) | 0x80n));
+    val >>= 7n;
+  }
+  bytes.push(Number(val & 0x7fn));
+  return new Uint8Array(bytes);
+}
+
+/**
+ * Decodes a protobuf varint from bytes at offset.
+ */
+export function decodeVarint(bytes: Uint8Array, offset: number): { value: number; bytesRead: number } {
+  let result = 0;
+  let shift = 0;
+  let count = 0;
+
+  while (offset + count < bytes.length) {
+    const b = bytes[offset + count];
+    count++;
+    result |= (b & 0x7f) << shift;
+    if ((b & 0x80) === 0) break;
+    shift += 7;
+    if (shift > 35) {
+      // For timestamps seconds, JS safe integers suffice.
+      break;
+    }
+  }
+
+  return { value: result, bytesRead: count };
+}
+
+/**
+ * Encodes RedeemResetRequest protobuf: field 1 (string token_id).
+ */
+export function encodeRedeemResetRequest(tokenId: string): Uint8Array {
+  const tokenBytes = new TextEncoder().encode(tokenId);
+  const tag = (1 << 3) | 2; // Field 1, Wire Type 2
+  const tagBytes = encodeVarint(tag);
+  const lenBytes = encodeVarint(tokenBytes.length);
+
+  const out = new Uint8Array(tagBytes.length + lenBytes.length + tokenBytes.length);
+  out.set(tagBytes, 0);
+  out.set(lenBytes, tagBytes.length);
+  out.set(tokenBytes, tagBytes.length + lenBytes.length);
+  return out;
+}
+
+/**
+ * Decodes a Timestamp submessage (field 1: int64 seconds).
+ */
+function decodeTimestamp(bytes: Uint8Array): number {
+  let offset = 0;
+  let seconds = 0;
+
+  while (offset < bytes.length) {
+    const { value: tag, bytesRead: tagLen } = decodeVarint(bytes, offset);
+    offset += tagLen;
+    const fieldNum = tag >> 3;
+    const wireType = tag & 0x7;
+
+    if (wireType === 0) {
+      const { value, bytesRead } = decodeVarint(bytes, offset);
+      offset += bytesRead;
+      if (fieldNum === 1) seconds = value;
+    } else if (wireType === 2) {
+      const { value: len, bytesRead } = decodeVarint(bytes, offset);
+      offset += bytesRead + len;
+    } else {
+      break;
+    }
+  }
+
+  return seconds;
+}
+
+/**
+ * Decodes a ConsumerResetToken submessage.
+ */
+function decodeConsumerResetToken(bytes: Uint8Array): GrokResetCoupon | null {
+  let offset = 0;
+  let tokenId = "";
+  let startSec = 0;
+  let endSec = 0;
+
+  while (offset < bytes.length) {
+    const { value: tag, bytesRead: tagLen } = decodeVarint(bytes, offset);
+    offset += tagLen;
+    const fieldNum = tag >> 3;
+    const wireType = tag & 0x7;
+
+    if (wireType === 2) {
+      const { value: len, bytesRead: lenRead } = decodeVarint(bytes, offset);
+      offset += lenRead;
+      const sub = bytes.subarray(offset, offset + len);
+      offset += len;
+
+      if (fieldNum === 10) {
+        tokenId = new TextDecoder("utf-8").decode(sub);
+      } else if (fieldNum === 20) {
+        startSec = decodeTimestamp(sub);
+      } else if (fieldNum === 30) {
+        endSec = decodeTimestamp(sub);
+      }
+    } else if (wireType === 0) {
+      const { bytesRead } = decodeVarint(bytes, offset);
+      offset += bytesRead;
+    } else {
+      break;
+    }
+  }
+
+  if (!tokenId) return null;
+
+  return {
+    tokenId,
+    validityStart: startSec > 0 ? new Date(startSec * 1000).toISOString() : "",
+    validityEnd: endSec > 0 ? new Date(endSec * 1000).toISOString() : "",
+  };
+}
+
+/**
+ * Decodes GetRemainingResetsResponse protobuf message: field 10 (repeated ConsumerResetToken).
+ */
+export function decodeGetRemainingResetsResponse(payload: Uint8Array): GrokResetCoupon[] {
+  const tokens: GrokResetCoupon[] = [];
+  let offset = 0;
+
+  while (offset < payload.length) {
+    const { value: tag, bytesRead: tagLen } = decodeVarint(payload, offset);
+    offset += tagLen;
+    const fieldNum = tag >> 3;
+    const wireType = tag & 0x7;
+
+    if (wireType === 2) {
+      const { value: len, bytesRead: lenRead } = decodeVarint(payload, offset);
+      offset += lenRead;
+      const sub = payload.subarray(offset, offset + len);
+      offset += len;
+
+      if (fieldNum === 10) {
+        const token = decodeConsumerResetToken(sub);
+        if (token) tokens.push(token);
+      }
+    } else if (wireType === 0) {
+      const { bytesRead } = decodeVarint(payload, offset);
+      offset += bytesRead;
+    } else {
+      break;
+    }
+  }
+
+  return tokens;
+}
+
+function buildGrokHeaders(accessToken: string): Record<string, string> {
+  return {
+    "Content-Type": "application/grpc-web+proto",
+    "X-Grpc-Web": "1",
+    "Accept": "application/grpc-web+proto",
+    "Authorization": `Bearer ${accessToken}`,
+    [XAI_GROK_COMPATIBILITY.headers.tokenAuth]: "xai-grok-cli",
+  };
+}
+
+/**
+ * Reads available Grok reset tokens for the authenticated xAI account.
+ */
+export async function getGrokRemainingResets(options: GetRemainingResetsOptions): Promise<{ tokens: GrokResetCoupon[] }> {
+  const fetchImpl = options.fetchFn ?? globalThis.fetch;
+  const endpoint = options.endpoint ?? GROK_GET_REMAINING_RESETS_ENDPOINT;
+  // BodyInit requires a plain ArrayBuffer backing store; the encoder's generic
+  // Uint8Array<ArrayBufferLike> is not assignable under TS 5.7 lib.dom types.
+  const emptyBody = encodeGrpcWebEnvelope(new Uint8Array(0)) as Uint8Array<ArrayBuffer>;
+
+  const res = await fetchImpl(endpoint, {
+    method: "POST",
+    headers: buildGrokHeaders(options.accessToken),
+    body: emptyBody,
+    signal: options.signal,
+  });
+
+  if (!res.ok) {
+    throw new Error(`GetRemainingResets HTTP error ${res.status}: ${res.statusText}`);
+  }
+
+  const rawBytes = new Uint8Array(await res.arrayBuffer());
+  const decoded = decodeGrpcWebResponse(rawBytes);
+
+  if (decoded.status !== 0) {
+    throw new GrpcWebError(decoded.status, decoded.statusMessage ?? "Unknown gRPC error");
+  }
+
+  if (decoded.messages.length === 0) {
+    return { tokens: [] };
+  }
+
+  return { tokens: decodeGetRemainingResetsResponse(decoded.messages[0]) };
+}
+
+/**
+ * Redeems a specific Grok reset token by tokenId.
+ */
+export async function redeemGrokResetCoupon(options: RedeemResetOptions): Promise<RedeemResetResult> {
+  const fetchImpl = options.fetchFn ?? globalThis.fetch;
+  const endpoint = options.endpoint ?? GROK_REDEEM_RESET_ENDPOINT;
+  const protoMessage = encodeRedeemResetRequest(options.tokenId);
+  const envelope = encodeGrpcWebEnvelope(protoMessage) as Uint8Array<ArrayBuffer>;
+
+  const res = await fetchImpl(endpoint, {
+    method: "POST",
+    headers: buildGrokHeaders(options.accessToken),
+    body: envelope,
+    signal: options.signal,
+  });
+
+  if (!res.ok) {
+    throw new Error(`RedeemReset HTTP error ${res.status}: ${res.statusText}`);
+  }
+
+  const rawBytes = new Uint8Array(await res.arrayBuffer());
+  const decoded = decodeGrpcWebResponse(rawBytes);
+
+  if (decoded.status !== 0) {
+    throw new GrpcWebError(decoded.status, decoded.statusMessage ?? "Unknown gRPC error");
+  }
+
+  return {
+    success: true,
+    status: decoded.status,
+    statusMessage: decoded.statusMessage,
+  };
+}

package/src/integrations/catalog-refresh.ts

@@ -10,7 +10,7 @@ import {
 /** Refresh only previously connected clients; a refused file never blocks its peers. */
 export async function refreshOwnedCatalogIntegrations(
   input: Omit<OwnedIntegrationRefreshInput, "clientId">,
-  clientIds: readonly IntegrationClientId[] = ["pi", "aside", "raycast"],
+  clientIds: readonly IntegrationClientId[] = ["pi", "aside", "raycast", "omo"],
 ): Promise<OwnedIntegrationRefreshOutcome[]> {
   let models: Promise<readonly ExportModel[]> | undefined;
   const loadModels = () => models ??= Promise.resolve().then(() =>

package/src/integrations/cline-document.ts

@@ -0,0 +1,73 @@
+import { PARSE_FAILED, parseConfig } from "./config-io";
+import { serializeDocument, UnserializableValueError } from "./serialize";
+
+/** Private journal representation, never written into either Cline file. */
+export interface ClineRawPair { settings: string | null; catalog: string | null }
+
+export function isClineObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function encodeClinePair(pair: ClineRawPair): string | null {
+  return pair.settings === null && pair.catalog === null ? null : JSON.stringify(pair);
+}
+
+export function decodeClinePair(text: string | null): ClineRawPair {
+  if (text === null) return { settings: null, catalog: null };
+  let value: unknown;
+  try { value = JSON.parse(text); }
+  catch { throw new UnserializableValueError("invalid Cline snapshot bundle"); }
+  if (!isClineObject(value) || Object.keys(value).length !== 2
+    || !(value.settings === null || typeof value.settings === "string")
+    || !(value.catalog === null || typeof value.catalog === "string")) {
+    throw new UnserializableValueError("invalid Cline snapshot bundle");
+  }
+  return { settings: value.settings, catalog: value.catalog };
+}
+
+function nativeDocument(value: unknown): value is Record<string, unknown> {
+  return isClineObject(value) && (value.version === undefined || value.version === 1)
+    && (value.providers === undefined || isClineObject(value.providers));
+}
+
+export function parseClineDocument(text: string | null): unknown | typeof PARSE_FAILED {
+  try {
+    const pair = decodeClinePair(text);
+    const settings = parseConfig(pair.settings, "json");
+    const catalog = parseConfig(pair.catalog, "json");
+    if (!nativeDocument(settings) || !nativeDocument(catalog)
+      || (settings.modes !== undefined && !isClineObject(settings.modes))) return PARSE_FAILED;
+    return { settings, catalog };
+  } catch { return PARSE_FAILED; }
+}
+
+export function serializeClineDocument(value: unknown): string {
+  if (!isClineObject(value)) throw new UnserializableValueError("invalid Cline document");
+  const settings = value.settings ?? {};
+  const catalog = value.catalog ?? {};
+  if (!nativeDocument(settings) || !nativeDocument(catalog)) {
+    throw new UnserializableValueError("unsupported Cline document version or providers shape");
+  }
+  return JSON.stringify({
+    settings: serializeDocument({ version: 1, modes: {}, providers: {}, ...settings }, "json"),
+    catalog: serializeDocument({ version: 1, providers: {}, ...catalog }, "json"),
+  });
+}
+
+/** Cline saves these two fields during normal model selection. Keep only a still-routed choice. */
+export function preserveClineSelection(previous: unknown, next: unknown): void {
+  if (!isClineObject(previous) || !isClineObject(next)) return;
+  const entry = (document: Record<string, unknown>, part: string): Record<string, unknown> | undefined => {
+    const root = document[part];
+    const providers = isClineObject(root) ? root.providers : undefined;
+    return isClineObject(providers) && isClineObject(providers.opencodex) ? providers.opencodex : undefined;
+  };
+  const old = entry(previous, "settings");
+  const current = entry(next, "settings");
+  const models = entry(next, "catalog")?.models;
+  if (!current || !isClineObject(current.settings) || !old || !isClineObject(old.settings)) return;
+  if (typeof old.settings.model === "string" && isClineObject(models) && Object.hasOwn(models, old.settings.model)) {
+    current.settings.model = old.settings.model;
+  }
+  if (typeof old.updatedAt === "string") current.updatedAt = old.updatedAt;
+}