grok-bot-sdk 0.0.0-stage → 0.75.8

package/bin/grok-bot-sdk.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { createLogin, pollLogin } from '../core.mjs';
+import { GrokBotClient } from '../sdk.mjs';
+
+const args = process.argv.slice(2);
+const command = args[0];
+const option = name => {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+const failed = code => {
+  console.log(JSON.stringify({ status: 'failed', code }));
+  process.exitCode = 1;
+};
+
+function usage() {
+  console.log(`grok-bot-sdk login [--no-open] --out <file>
+grok-bot-sdk whoami [--token-file <file>]
+grok-bot-sdk bots [--token-file <file>]
+grok-bot-sdk sessions --bot <id> [--token-file <file>]
+grok-bot-sdk transcript --bot <id> [--session <id>] [--limit <n>] [--token-file <file>]
+grok-bot-sdk tasks --bot <id> [--session <id>] [--token-file <file>]
+grok-bot-sdk capabilities [--token-file <file>]
+grok-bot-sdk box [--token-file <file>]
+
+login opens the browser, waits for approval, and writes the session to <file> (mode 0600).
+The command prints the login page URL and a redacted summary. It does not print tokens.
+whoami reads GROK_BOT_ACCESS_TOKEN, or the accessToken field inside --token-file, and prints only whether account fields exist.
+The other commands are read-only. They print roster, session, transcript, task, capability, or box fields for the saved token.`);
+  process.exitCode = 2;
+}
+
+async function login() {
+  const out = option('--out');
+  if (!out || out.startsWith('-')) {
+    usage();
+    return;
+  }
+  const flow = createLogin();
+  console.log(JSON.stringify({ phase: 'browser-login', loginUrl: flow.loginUrl }));
+  if (!args.includes('--no-open') && process.platform === 'darwin') {
+    execFileSync('/usr/bin/open', [flow.loginUrl], { stdio: 'ignore' });
+  }
+  const session = await pollLogin(flow, {
+    onPending: attempt => {
+      if (attempt === 1 || attempt % 6 === 0) console.log(JSON.stringify({ phase: 'awaiting-browser-authorization', attempt }));
+    },
+  });
+  const path = resolve(out);
+  await mkdir(dirname(path), { recursive: true });
+  const body = {
+    accessToken: session.accessToken,
+    refreshToken: session.refreshToken,
+    ...session.selectedTeamId !== undefined ? { selectedTeamId: session.selectedTeamId } : {},
+  };
+  await writeFile(path, JSON.stringify(body, null, 2) + '\n', { mode: 0o600 });
+  console.log(JSON.stringify({
+    phase: 'saved',
+    path,
+    accessTokenPresent: true,
+    refreshTokenPresent: true,
+    selectedTeamIdPresent: session.selectedTeamId !== undefined,
+    persistedBySdk: false,
+    refreshImplemented: false,
+  }));
+}
+
+async function loadToken() {
+  const file = option('--token-file');
+  if (file) {
+    const parsed = JSON.parse(await readFile(resolve(file), 'utf8'));
+    if (typeof parsed?.accessToken !== 'string' || !parsed.accessToken) throw new Error('TOKEN_FILE_INVALID');
+    return { accessToken: parsed.accessToken, teamId: parsed.selectedTeamId, version: parsed.version };
+  }
+  const accessToken = process.env.GROK_BOT_ACCESS_TOKEN;
+  if (!accessToken) throw new Error('MISSING_ACCESS_TOKEN');
+  return { accessToken, version: process.env.GROK_BOT_CLIENT_VERSION };
+}
+
+async function clientFromToken() {
+  const loaded = await loadToken();
+  return new GrokBotClient({
+    accessToken: loaded.accessToken,
+    ...loaded.version ? { version: loaded.version } : {},
+    ...loaded.teamId !== undefined ? { teamId: loaded.teamId } : {},
+  });
+}
+
+async function whoami() {
+  const client = await clientFromToken();
+  const me = await client.getMe();
+  console.log(JSON.stringify({
+    status: 'ok',
+    identityPresent: Boolean(me.authId || me.userId),
+    emailPresent: Boolean(me.email),
+    teamPresent: me.teamId !== undefined && me.teamId !== null,
+  }));
+}
+
+function requireBot() {
+  const bot = option('--bot');
+  if (!bot || bot.startsWith('-')) {
+    usage();
+    return undefined;
+  }
+  return bot;
+}
+
+async function bots() {
+  const roster = await (await clientFromToken()).listBots();
+  console.log(JSON.stringify({
+    status: 'ok',
+    count: roster.bots.length,
+    truncated: roster.truncated,
+    slackConnectionCount: roster.slackConnections.length,
+    teamsConnectionCount: roster.teamsConnections.length,
+    bots: roster.bots.map(bot => ({
+      id: bot.id,
+      name: bot.name,
+      kind: bot.kind,
+      role: bot.role,
+      sessionId: bot.sessionId,
+    })),
+  }));
+}
+
+async function sessions() {
+  const bot = requireBot();
+  if (!bot) return;
+  const result = await (await clientFromToken()).listSessions(bot);
+  console.log(JSON.stringify({ status: 'ok', count: result.sessions.length, sessions: result.sessions }));
+}
+
+async function transcript() {
+  const bot = requireBot();
+  if (!bot) return;
+  const limitText = option('--limit');
+  const limit = limitText === undefined ? 20 : Number(limitText);
+  const result = await (await clientFromToken()).listTranscript({
+    botId: bot,
+    sessionId: option('--session') ?? '',
+    limit,
+  });
+  console.log(JSON.stringify({
+    status: 'ok',
+    generation: result.generation,
+    count: result.entries.length,
+    cloudAgentPeerIdsKnown: result.cloudAgentPeerIdsKnown,
+    peerCount: result.cloudAgentPeerIds.length,
+    unreadAnchor: result.unreadAnchor,
+    entries: result.entries.map(entry => ({
+      seq: entry.seq,
+      updatedSeq: entry.updatedSeq,
+      entryId: entry.entryId,
+      entryKind: entry.entryKind,
+      bodyOmitted: entry.bodyOmitted,
+      bodyKind: typeof entry.body?.kind === 'string' ? entry.body.kind : null,
+    })),
+  }));
+}
+
+async function tasks() {
+  const bot = requireBot();
+  if (!bot) return;
+  const client = await clientFromToken();
+  const sessionId = option('--session') ?? '';
+  const [agentTasks, taskList] = await Promise.all([
+    client.listAgentTasks({ botId: bot }),
+    client.listTasks({ botId: bot, sessionId }),
+  ]);
+  console.log(JSON.stringify({
+    status: 'ok',
+    agentTaskCount: agentTasks.tasks.length,
+    taskCount: taskList.tasks.length,
+    agentTasks: agentTasks.tasks,
+    tasks: taskList.tasks,
+  }));
+}
+
+async function capabilities() {
+  const result = await (await clientFromToken()).getRuntimeCapabilities();
+  console.log(JSON.stringify({ status: 'ok', ...result }));
+}
+
+async function box() {
+  const result = await (await clientFromToken()).getSandBoxRunState();
+  console.log(JSON.stringify({ status: 'ok', ...result }));
+}
+
+try {
+  if (command === 'login') await login();
+  else if (command === 'whoami') await whoami();
+  else if (command === 'bots') await bots();
+  else if (command === 'sessions') await sessions();
+  else if (command === 'transcript') await transcript();
+  else if (command === 'tasks') await tasks();
+  else if (command === 'capabilities') await capabilities();
+  else if (command === 'box') await box();
+  else usage();
+} catch (error) {
+  const code = error instanceof Error && /^[A-Z_]{1,80}$/.test(error.message) ? error.message : 'COMMAND_FAILED';
+  failed(code);
+}

package/connect-stream.mjs

@@ -0,0 +1,36 @@
+import {SDKError} from './errors.mjs';
+export function encodeConnectFrame(data){
+  const payload=Buffer.from(JSON.stringify(data));
+  const header=Buffer.alloc(5);header.writeUInt32BE(payload.length,1);
+  return Buffer.concat([header,payload]);
+}
+
+export async function* readConnectFrames(body,{maxFrameBytes=1024*1024,onClose=()=>{}}={}){
+  if(!body?.getReader)throw new SDKError('STREAM_INVALID_RESPONSE');
+  const reader=body.getReader(),decoder=new TextDecoder('utf-8',{fatal:true});
+  let pending=Buffer.alloc(0);
+  try{
+    for(;;){
+      const {value,done}=await reader.read();
+      if(done)throw new SDKError('STREAM_UNEXPECTED_EOF');
+      pending=Buffer.concat([pending,Buffer.from(value)]);
+      while(pending.length>=5){
+        const flags=pending[0],length=pending.readUInt32BE(1);
+        if(length>maxFrameBytes)throw new SDKError('STREAM_FRAME_TOO_LARGE');
+        if(flags&1)throw new SDKError('STREAM_COMPRESSION_UNSUPPORTED');
+        if(flags!==0&&flags!==2)throw new SDKError('STREAM_FLAGS_INVALID');
+        if(pending.length<5+length)break;
+        let data;
+        try{data=JSON.parse(decoder.decode(pending.subarray(5,5+length)));}catch{throw new SDKError('STREAM_INVALID_JSON');}
+        pending=pending.subarray(5+length);
+        if(!data||typeof data!=='object'||Array.isArray(data))throw new SDKError('STREAM_INVALID_JSON');
+        if(flags===2){
+          if(Object.hasOwn(data,'error'))throw new SDKError('STREAM_RPC_ERROR');
+          if(pending.length)throw new SDKError('STREAM_END_INVALID');
+          return;
+        }
+        yield data;
+      }
+    }
+  }finally{onClose();await reader.cancel().catch(()=>{});reader.releaseLock();}
+}

package/core.mjs

@@ -0,0 +1,135 @@
+import { randomBytes, randomUUID, createHash, pbkdf2Sync, createDecipheriv } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+export const API_ORIGIN = 'https://api2.cursor.sh';
+const fixedError = code => new Error(code);
+
+export function createLogin() {
+  const verifier = randomBytes(32).toString('base64url');
+  const uuid = randomUUID();
+  const url = new URL('/loginDeepControl', 'https://cursor.com');
+  url.search = new URLSearchParams({challenge:createHash('sha256').update(verifier).digest('base64url'),uuid,mode:'login',redirectTarget:'sand',supportsSelectedTeamLogin:'true'}).toString();
+  return {uuid,verifier,loginUrl:url.toString()};
+}
+
+export function decryptMacSecret(value, password) {
+  try {
+    const bytes = Buffer.from(value,'base64');
+    if (bytes.subarray(0,3).toString() !== 'v10' || bytes.length < 19) throw fixedError('FORMAT');
+    const key=pbkdf2Sync(password,'saltysalt',1003,16,'sha1');
+    try {
+      const decipher=createDecipheriv('aes-128-cbc',key,Buffer.alloc(16,32));
+      return Buffer.concat([decipher.update(bytes.subarray(3)),decipher.final()]).toString('utf8');
+    } finally {key.fill(0);}
+  } catch {throw fixedError('CREDENTIAL_DECRYPT_FAILED');}
+}
+
+export function selectDesktopAccount(doc) {
+  let record;
+  try {record=JSON.parse(doc['cursor-accounts']);} catch {throw fixedError('ACCOUNT_STORE_INVALID');}
+  if (typeof record.active !== 'string' || !record.accounts?.[record.active]) throw fixedError('NO_ACTIVE_ACCOUNT');
+  const active=record.accounts[record.active];
+  if (typeof active['cursor-access-token'] !== 'string') throw fixedError('ACCESS_TOKEN_MISSING');
+  return {encryptedAccessToken:active['cursor-access-token'],encryptedTeamId:active['cursor-selected-team-id'],storedMachineId:doc['cursor-machine-id']};
+}
+
+export function validateOrigin(value, kind) {
+  try {
+    const u=new URL(value);
+    const allowed=kind==='cursor' ? u.origin===API_ORIGIN : u.hostname.endsWith('.cursorvm.com');
+    if (!allowed || u.protocol!=='https:' || u.username || u.password || u.search || u.hash || (u.port && u.port!=='443')) throw fixedError('ORIGIN');
+    if (kind==='cursor' && u.pathname!=='/') throw fixedError('PATH');
+    return u.toString().replace(/\/$/,'');
+  } catch {throw fixedError('UNTRUSTED_ORIGIN');}
+}
+
+function checksum(machineId) {
+  const t=Math.floor(Date.now()/1e6);
+  const bytes=Uint8Array.from([t>>40&255,t>>32&255,t>>24&255,t>>16&255,t>>8&255,t&255]);
+  let previous=165;
+  for(let i=0;i<bytes.length;i++){bytes[i]=(bytes[i]^previous)+i%256;previous=bytes[i];}
+  return Buffer.from(bytes).toString('base64url')+machineId;
+}
+
+export function clientHeaders({accessToken,version,machineId,teamId}) {
+  const headers={
+    'content-type':'application/json','connect-protocol-version':'1',
+    'authorization':`Bearer ${accessToken}`,'x-cursor-client-type':'sand',
+    'x-cursor-client-version':version,'x-cursor-client-source':'sand-desktop',
+    'x-cursor-client-os':'darwin','x-sand-box-namespace':'prod','x-ghost-mode':'true',
+    'x-request-id':randomUUID(),
+    'user-agent':`Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Sand/${version} Safari/537.36`,
+  };
+  if(machineId)headers['x-cursor-checksum']=checksum(machineId);
+  if(teamId!==undefined)headers['x-cursor-team-id']=String(teamId);
+  return headers;
+}
+
+export async function requestJSON(url,{method='POST',headers={},body,fetchImpl=fetch,timeoutMs=20000,signal}={}) {
+  try {
+    const timeout=AbortSignal.timeout(timeoutMs);
+    const response=await fetchImpl(url,{method,headers,body:body===undefined?undefined:JSON.stringify(body),redirect:'error',signal:signal?AbortSignal.any([signal,timeout]):timeout});
+    const text=await response.text();
+    if(Buffer.byteLength(text)>8*1024*1024) return {ok:false,httpStatus:response.status,code:'RESPONSE_TOO_LARGE'};
+    let data;
+    try {data=JSON.parse(text);} catch {return {ok:false,httpStatus:response.status,code:'NON_JSON_RESPONSE'};}
+    const rawCode=typeof data?.code==='string'?data.code:typeof data?.error==='string'?data.error:'';
+    if(!response.ok) return {ok:false,httpStatus:response.status,code:/^[a-z_]{1,48}$/.test(rawCode)?rawCode:'HTTP_ERROR'};
+    return {ok:true,httpStatus:response.status,data};
+  } catch {return {ok:false,code:'NETWORK_OR_TLS_ERROR'};}
+}
+
+export async function verify(options) {
+  const report={mode:options.mode??'desktop-existing-session',clientVersion:options.version,steps:[]};
+  const headers=clientHeaders(options);
+  const rpc=async(method,body)=>requestJSON(API_ORIGIN+'/'+method,{headers,body,fetchImpl:options.fetchImpl});
+  const checked=(result,predicate)=>result.ok&&!predicate(result.data)?{ok:false,httpStatus:result.httpStatus,code:'INVALID_RESPONSE'}:result;
+  const record=(name,result,extra={})=>report.steps.push({name,status:result.ok?'passed':'failed',httpStatus:result.httpStatus,...result.code?{code:result.code}:{},...extra});
+  const me=checked(await rpc('aiserver.v1.DashboardService/GetMe',{}),data=>!!(data?.authId||data?.userId));
+  record('account.GetMe',me,{...me.ok?{identityPresent:!!(me.data.authId||me.data.userId),emailPresent:!!me.data.email}:{}});
+  if(!me.ok)return report;
+  if(options.cloudRoster){
+    const roster=checked(await rpc('aiserver.v1.GrokBotService/ListGrokBotAgents',{includeTeamAgents:true}),data=>Array.isArray(data?.agents)&&data.agents.every(x=>x&&typeof x==='object'));
+    record('cloud.ListGrokBotAgents',roster,{...roster.ok?{agentsArrayPresent:Array.isArray(roster.data.agents)}:{}});
+    if(roster.ok&&Array.isArray(roster.data.agents)){
+      report.cloudBotCount=roster.data.agents.length;
+      report.cloudRoster={truncated:roster.data.truncated===true,avatarMetadataCount:roster.data.agents.filter(x=>!!(x.avatarShape||x.avatarColor||x.avatarDataUrl)).length,harnessCounts:roster.data.agents.reduce((counts,x)=>{const harness=typeof x.harness==='string'&&/^[a-z_]{1,30}$/.test(x.harness)?x.harness:'other';counts[harness]=(counts[harness]??0)+1;return counts;},{})};
+    }
+    if(options.cloudOnly)return report;
+  }
+  const box=checked(await rpc('aiserver.v1.GrokBotService/EnsureSandBox',{wake:false,supportsAsleepBox:true}),data=>data&&typeof data==='object'&&!Array.isArray(data)&&data.runState!==undefined);
+  record('broker.EnsureSandBox(no-wake)',box);
+  if(!box.ok)return report;
+  const {gatewayUrl,gatewayToken,networkToken,runState}=box.data;
+  report.connection={gatewayURLPresent:!!gatewayUrl,gatewayTokenPresent:!!gatewayToken,networkTokenPresent:!!networkToken,runState:typeof runState==='string'&&/^[A-Z_]{1,80}$/.test(runState)?runState:typeof runState==='number'?runState:'unknown'};
+  if(!gatewayUrl || !gatewayToken){report.steps.push({name:'gateway',status:'host_not_running'});return report;}
+  let base;
+  try{base=validateOrigin(gatewayUrl,'gateway');}catch{report.steps.push({name:'gateway',status:'failed',code:'UNTRUSTED_ORIGIN'});return report;}
+  const gatewayHeaders={'authorization':`Bearer ${gatewayToken}`,'content-type':'application/json'};
+  if(networkToken)gatewayHeaders['x-anyrun-network-token']=networkToken;
+  const health=checked(await requestJSON(base+'/health',{method:'GET',headers:gatewayHeaders,fetchImpl:options.fetchImpl}),data=>data?.ok===true);
+  record('gateway.health',health,{...health.ok?{reportedOK:health.data.ok===true}:{}});
+  if(!health.ok)return report;
+  const roster=checked(await requestJSON(base+'/api/listAgents',{headers:gatewayHeaders,body:{},fetchImpl:options.fetchImpl}),data=>Array.isArray(data)&&data.every(x=>x&&typeof x==='object'));
+  record('gateway.listAgents',roster,{...roster.ok?{arrayResponse:Array.isArray(roster.data)}:{}});
+  if(roster.ok&&Array.isArray(roster.data)){
+    report.botCount=roster.data.length;
+    report.rosterMetadata={hiddenCount:roster.data.filter(x=>x.isHiddenFromSidebar===true).length,groupCount:roster.data.filter(x=>x.isGroup===true).length,avatarCount:roster.data.filter(x=>!!(x.avatarDataUrl||x.avatarVersion||x.avatarShape)).length};
+  }
+  return report;
+}
+
+export async function pollLogin(flow,{fetchImpl=fetch,sleep=delay,maxAttempts=150,onPending=()=>{}}={}) {
+  const url=new URL('/auth/poll',API_ORIGIN);
+  url.search=new URLSearchParams({uuid:flow.uuid,verifier:flow.verifier}).toString();
+  let errors=0;
+  for(let attempt=0;attempt<maxAttempts;attempt++){
+    const result=await requestJSON(url,{method:'GET',headers:{'content-type':'application/json'},fetchImpl});
+    if(result.ok && typeof result.data.accessToken==='string' && typeof result.data.refreshToken==='string')return result.data;
+    if(result.httpStatus===403 && result.code==='sign_in_policy_violation')throw fixedError('SIGN_IN_POLICY_VIOLATION');
+    if(result.httpStatus===404){errors=0;onPending(attempt+1);}
+    else if(++errors>=3)throw fixedError('LOGIN_POLL_FAILED');
+    await sleep(Math.min(1000*1.2**attempt,10000));
+  }
+  throw fixedError('LOGIN_TIMED_OUT');
+}

package/desktop.d.mts

@@ -0,0 +1,3 @@
+import type { ClientOptions } from './sdk.mjs';
+export function version(): string;
+export function desktopCredentials(): Promise<ClientOptions & {version: string}>;

package/desktop.mjs

@@ -0,0 +1,28 @@
+import {readFile} from 'node:fs/promises';
+import {execFileSync} from 'node:child_process';
+import {homedir} from 'node:os';
+import {join} from 'node:path';
+import {selectDesktopAccount,decryptMacSecret} from './core.mjs';
+
+const app='/Applications/Grok Bot.app';
+export function version(){return execFileSync('/usr/libexec/PlistBuddy',['-c','Print :CFBundleShortVersionString',app+'/Contents/Info.plist'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}).trim();}
+export async function desktopCredentials(){
+  const doc=JSON.parse(await readFile(join(homedir(),'Library/Application Support/Grok Bot/sand-secrets.json'),'utf8'));
+  const selected=selectDesktopAccount(doc);
+  let password;
+  try{password=execFileSync('/usr/bin/security',['find-generic-password','-s','Grok Bot Safe Storage','-w'],{encoding:'utf8',timeout:15000,stdio:['ignore','pipe','pipe']}).trimEnd();}
+  catch{throw new Error('KEYCHAIN_ACCESS_UNAVAILABLE');}
+  const accessToken=decryptMacSecret(selected.encryptedAccessToken,password);
+  let machineId,teamId;
+  if(selected.storedMachineId){
+    const wrapped=selected.storedMachineId.replace(/^scoped:v1:[a-f0-9]{64}:/,'');
+    if(wrapped.startsWith('plaintext:v1:'))machineId=wrapped.slice('plaintext:v1:'.length);
+    else machineId=decryptMacSecret(wrapped,password);
+  }
+  if(selected.encryptedTeamId){
+    const value=decryptMacSecret(selected.encryptedTeamId,password);
+    if(/^\d+$/.test(value))teamId=Number(value);
+  }
+  password=undefined;
+  return {accessToken,machineId,teamId,version:version()};
+}

package/errors.mjs

@@ -0,0 +1,4 @@
+const CODES=new Set(['SDK_ERROR','MISSING_ACCESS_TOKEN','RPC_FAILED','ACCOUNT_AUTH_FAILED','INVALID_ROSTER_RESPONSE','INVALID_BOT_RECORD','BOT_ID_REQUIRED','MESSAGE_INVALID','SEND_UNCONFIRMED','SEND_REFUSED','CURSOR_INVALID','CURSOR_SCOPE_MISMATCH','STREAM_CONNECTION_FAILED','STREAM_RPC_ERROR','STREAM_FRAME_TOO_LARGE','STREAM_UNEXPECTED_EOF','STREAM_COMPRESSION_UNSUPPORTED','STREAM_FLAGS_INVALID','STREAM_INVALID_JSON','STREAM_END_INVALID','STREAM_INVALID_RESPONSE','STREAM_PROTOCOL_ERROR','STREAM_CANCELLED']);
+export class SDKError extends Error{
+  constructor(code,httpStatus){super(CODES.has(code)?code:'SDK_ERROR');this.name='SDKError';this.code=this.message;if(Number.isInteger(httpStatus))this.httpStatus=httpStatus;}
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "grok-bot-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.75.8",
+  "description": "Unofficial Node.js SDK for the Grok Bot 0.75.8 desktop client protocol: login, roster, sessions, transcript, tasks, send, and Connect-to-SSE replies.",
+  "license": "MIT",
+  "type": "module",
+  "author": "RongleCat (铁柱AGI)",
+  "homepage": "https://ronglecat.github.io/grok-bot-sdk/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RongleCat/grok-bot-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/RongleCat/grok-bot-sdk/issues"
+  },
+  "keywords": [
+    "grok",
+    "grok-bot",
+    "sdk"
+  ],
+  "engines": {
+    "node": ">=22.13"
+  },
+  "bin": {
+    "grok-bot-sdk": "./bin/grok-bot-sdk.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./sdk.d.mts",
+      "import": "./sdk.mjs"
+    },
+    "./avatar": {
+      "types": "./avatar.d.mts",
+      "import": "./avatar.mjs"
+    },
+    "./desktop": {
+      "types": "./desktop.d.mts",
+      "import": "./desktop.mjs"
+    }
+  },
+  "types": "./sdk.d.mts",
+  "files": [
+    "*.mjs",
+    "*.d.mts",
+    "bin",
+    "README.md",
+    "README_ZH.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitepress": "^1.6.4"
+  }
+}