grok-bot-cli 0.3.0 → 0.4.0

package/src/gateway.js

@@ -1,361 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { ensureSandboxHeaders, headersFromEnsureSandbox, headersFromEnv, mergeGatewayHeaders, normalizeHeaderMap, requestHeaders } from "./headers.js";
-import { hasGrokBotGatewaySession, loadGrokBotGatewaySession } from "./app-session.js";
-import { AVATAR_COLORS, AVATAR_SHAPES, MAX_GROUP_MEMBERS } from "./store.js";
-import { assertAllowedCredentialUrl, redactSecrets } from "./url-policy.js";
-
-export class GatewayError extends Error {
-  constructor(message, { status, method } = {}) {
-    super(message);
-    this.name = "GatewayError";
-    this.status = status;
-    this.method = method;
-  }
-}
-
-// ponytail: fixed 30 s deadline and buffered byte cap; upgrade path is per-method budgets plus streaming reads.
-export const GATEWAY_TIMEOUT_MS = 30000;
-export const GATEWAY_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
-
-function backendBase() {
-  return (
-    process.env.SAND_BACKEND_URL ||
-    process.env.CURSOR_API_BASE_URL ||
-    "https://api2.cursor.sh"
-  ).replace(/\/$/, "");
-}
-
-function accessTokenFromEnv() {
-  return (
-    process.env.CURSOR_ACCESS_TOKEN ||
-    process.env.GROK_BOT_ACCESS_TOKEN ||
-    process.env.SAND_ACCESS_TOKEN ||
-    ""
-  ).trim();
-}
-
-function gatewayTokenFromEnv() {
-  return (
-    process.env.GROK_BOT_GATEWAY_TOKEN ||
-    process.env.SAND_HOST_GATEWAY_TOKEN ||
-    process.env.SAND_GATEWAY_TOKEN ||
-    ""
-  ).trim();
-}
-
-function gatewayOverride() {
-  const token = gatewayTokenFromEnv();
-  const explicitUrl = (process.env.GROK_BOT_GATEWAY_URL || process.env.SAND_HOST_GATEWAY_URL || "").trim();
-  const localUrl = token
-    ? "http://127.0.0.1:" + (process.env.SAND_HOST_PORT || "1340")
-    : "";
-  const url = explicitUrl || localUrl;
-  if (url && token) {
-    return {
-      gatewayUrl: assertAllowedCredentialUrl(url.replace(/\/$/, ""), { kind: "gateway" }),
-      gatewayToken: token,
-      gatewayHeaders: headersFromEnv(),
-    };
-  }
-  return null;
-}
-
-function sessionFromApp() {
-  let loaded;
-  try {
-    loaded = loadGrokBotGatewaySession();
-  } catch (error) {
-    // Descriptor present but unusable (e.g. Windows Local State missing). Fall
-    // through to CURSOR_ACCESS_TOKEN → EnsureSandBox when that token is set.
-    if (accessTokenFromEnv()) return null;
-    throw error instanceof Error ? new GatewayError(error.message) : error;
-  }
-  if (!loaded) return null;
-  return {
-    gatewayUrl: assertAllowedCredentialUrl(loaded.gatewayUrl, { kind: "gateway" }),
-    gatewayToken: loaded.gatewayToken,
-    gatewayHeaders: mergeGatewayHeaders(normalizeHeaderMap(loaded.headers), headersFromEnv()),
-  };
-}
-
-export function hasGatewayAuth() {
-  return Boolean(gatewayOverride() || accessTokenFromEnv() || hasGrokBotGatewaySession());
-}
-
-async function readJson(res) {
-  const text = await res.text();
-  if (text.length > GATEWAY_MAX_RESPONSE_BYTES) {
-    throw new GatewayError("Gateway response too large (" + text.length + " bytes, limit " + GATEWAY_MAX_RESPONSE_BYTES + ")");
-  }
-  if (!text) return {};
-  try {
-    return JSON.parse(text);
-  } catch {
-    return { raw: text };
-  }
-}
-
-function pick(obj, ...keys) {
-  if (!obj || typeof obj !== "object") return undefined;
-  for (const key of keys) {
-    if (obj[key] != null && obj[key] !== "") return obj[key];
-  }
-  return undefined;
-}
-
-export async function ensureSandbox(accessToken) {
-  const url = assertAllowedCredentialUrl(backendBase(), { kind: "backend" }) + "/aiserver.v1.GrokBotService/EnsureSandBox";
-  const res = await fetch(url, {
-    method: "POST",
-    redirect: "error",
-    signal: AbortSignal.timeout(GATEWAY_TIMEOUT_MS),
-    headers: ensureSandboxHeaders(accessToken),
-    body: "{}",
-  });
-  const body = await readJson(res);
-  if (!res.ok) {
-    const detail = body.message || body.error || body.raw || res.statusText;
-    throw new GatewayError("EnsureSandBox failed: " + res.status + " " + redactSecrets(detail), { status: res.status, method: "EnsureSandBox" });
-  }
-  const gatewayUrl = pick(body, "gatewayUrl", "gateway_url");
-  const gatewayToken = pick(body, "gatewayToken", "gateway_token");
-  if (!gatewayUrl || !gatewayToken) {
-    throw new GatewayError("EnsureSandBox returned no gatewayUrl/gatewayToken. Auth may be a dashboard API key (those do not work).");
-  }
-  return { gatewayUrl: assertAllowedCredentialUrl(String(gatewayUrl).replace(/\/$/, ""), { kind: "gateway" }), gatewayToken: String(gatewayToken), gatewayHeaders: mergeGatewayHeaders(headersFromEnsureSandbox(body), headersFromEnv()) };
-}
-
-export async function connectGateway() {
-  const override = gatewayOverride();
-  if (override) return override;
-  const fromApp = sessionFromApp();
-  if (fromApp) return fromApp;
-  const token = accessTokenFromEnv();
-  if (!token) {
-    throw new GatewayError("Set CURSOR_ACCESS_TOKEN, or GROK_BOT_GATEWAY_URL + GROK_BOT_GATEWAY_TOKEN. Do not use a Cursor dashboard API key.");
-  }
-  return ensureSandbox(token);
-}
-
-export async function gatewayCall(session, method, body = {}) {
-  const base = assertAllowedCredentialUrl(session.gatewayUrl, { kind: "gateway" });
-  const url = base + "/api/" + method;
-  const res = await fetch(url, {
-    method: "POST",
-    redirect: "error",
-    signal: AbortSignal.timeout(GATEWAY_TIMEOUT_MS),
-    headers: requestHeaders(session),
-    body: JSON.stringify(body),
-  });
-  const data = await readJson(res);
-  if (!res.ok) {
-    const detail = data.message || data.error || data.raw || res.statusText;
-    throw new GatewayError(method + " failed: " + res.status + " " + redactSecrets(String(detail).slice(0, 300)), { status: res.status, method });
-  }
-  return data;
-}
-
-function asRecord(agent) {
-  if (!agent) return null;
-  const id = agent.id || agent.agentId;
-  const memberIds = agent.memberIds || agent.memberAgentIds || [];
-  const notify = agent.notifyOnUpdatesEnabled ?? agent.notifyOnAgentUpdates;
-  const hidden = agent.isHiddenFromSidebar ?? agent.hiddenFromSidebar;
-  return {
-    id,
-    name: agent.name || "",
-    title: agent.title || "",
-    description: agent.description || "",
-    avatarShape: agent.avatarShape || "",
-    avatarColor: agent.avatarColor || "",
-    ...(notify !== undefined ? { notifyOnAgentUpdates: Boolean(notify) } : {}),
-    ...(hidden !== undefined ? { hiddenFromSidebar: Boolean(hidden) } : {}),
-    isGroup: agent.isGroup === true || (agent.isGroup == null && Array.isArray(memberIds) && memberIds.length > 0),
-    memberIds: Array.isArray(memberIds) ? memberIds : [],
-  };
-}
-
-function assertAvatar(kind, value, allowed) {
-  const trimmed = (value ?? "").trim();
-  if (!trimmed) return "";
-  if (!allowed.includes(trimmed)) {
-    throw new GatewayError("Unknown avatar " + kind + " \"" + value + "\". Use: " + allowed.join(" "));
-  }
-  return trimmed;
-}
-
-function unwrapList(data) {
-  if (Array.isArray(data)) return data;
-  if (Array.isArray(data.agents)) return data.agents;
-  if (data.agent) return [data.agent];
-  return [];
-}
-
-function unwrapOne(data) {
-  return asRecord(data.agent || data);
-}
-
-export async function listAgents(session) {
-  const data = await gatewayCall(session, "listAgents", {});
-  return unwrapList(data).map(asRecord).filter((r) => r && r.id);
-}
-
-function resolveFromList(records, ref) {
-  const needle = String(ref).trim().toLowerCase();
-  const byId = records.find((r) => r.id.toLowerCase() === needle);
-  if (byId) return byId;
-  const matches = records.filter((r) => r.name.toLowerCase() === needle || r.title.toLowerCase() === needle);
-  if (matches.length === 1) return matches[0];
-  if (matches.length === 0) throw new GatewayError("No bot or group named \"" + ref + "\"");
-  throw new GatewayError("Ambiguous name \"" + ref + "\"");
-}
-
-export async function resolveRef(session, ref) {
-  return resolveFromList(await listAgents(session), ref);
-}
-
-export async function createAgent(session, input) {
-  const data = await gatewayCall(session, "createAgent", {
-    name: input.name,
-    description: input.description || "",
-    title: input.title || "",
-    avatarShape: assertAvatar("shape", input.avatarShape, AVATAR_SHAPES),
-    avatarColor: assertAvatar("color", input.avatarColor, AVATAR_COLORS),
-    origin: "user",
-  });
-  return unwrapOne(data);
-}
-
-export async function updateAgent(session, ref, patch = {}) {
-  const rec = await resolveRef(session, ref);
-  if (patch.name !== undefined && !String(patch.name).trim()) {
-    throw new GatewayError("Name cannot be blank.");
-  }
-  const profile = {
-    name: patch.name !== undefined ? String(patch.name).trim() : rec.name,
-    description: patch.description !== undefined ? String(patch.description) : rec.description,
-  };
-  if (patch.title !== undefined) profile.title = String(patch.title);
-  if (patch.avatarShape !== undefined) profile.avatarShape = assertAvatar("shape", patch.avatarShape, AVATAR_SHAPES);
-  if (patch.avatarColor !== undefined) profile.avatarColor = assertAvatar("color", patch.avatarColor, AVATAR_COLORS);
-  await gatewayCall(session, "updateAgent", { id: rec.id, profile });
-  if (patch.notifyOnAgentUpdates !== undefined) {
-    await gatewayCall(session, "setAgentNotifyOnUpdates", { id: rec.id, isEnabled: Boolean(patch.notifyOnAgentUpdates) });
-  }
-  if (patch.hiddenFromSidebar !== undefined) {
-    await gatewayCall(session, "setAgentHiddenFromSidebar", { id: rec.id, isHidden: Boolean(patch.hiddenFromSidebar) });
-  }
-  const fresh = (await listAgents(session)).find((r) => r.id === rec.id);
-  return fresh || rec;
-}
-
-export async function deleteAgent(session, ref) {
-  const rec = await resolveRef(session, ref);
-  await gatewayCall(session, "deleteAgent", { id: rec.id });
-  return rec;
-}
-
-function normalizeMemberIds(records, memberRefs) {
-  const memberIds = new Set();
-  for (const ref of memberRefs) {
-    const rec = resolveFromList(records, ref);
-    if (rec.isGroup) {
-      throw new GatewayError(`Cannot add group "${rec.name}" as a member. Nested groups are not allowed.`);
-    }
-    memberIds.add(rec.id);
-  }
-  if (memberIds.size === 0) {
-    throw new GatewayError("A group needs at least one existing member agent.");
-  }
-  if (memberIds.size > MAX_GROUP_MEMBERS) {
-    throw new GatewayError(`A group can have at most ${MAX_GROUP_MEMBERS} members.`);
-  }
-  return [...memberIds];
-}
-
-export async function createGroup(session, input) {
-  const records = await listAgents(session);
-  const memberAgentIds = normalizeMemberIds(records, input.memberIds || []);
-  const data = await gatewayCall(session, "createGroup", {
-    name: input.name,
-    description: input.description || "",
-    memberAgentIds,
-  });
-  const rec = unwrapOne(data);
-  const extras = {};
-  if (input.title) extras.title = input.title;
-  if (input.avatarShape) extras.avatarShape = input.avatarShape;
-  if (input.avatarColor) extras.avatarColor = input.avatarColor;
-  if (Object.keys(extras).length && rec?.id) return updateAgent(session, rec.id, extras);
-  return rec;
-}
-
-export async function setGroupMembers(session, groupRef, memberRefs) {
-  const records = await listAgents(session);
-  const group = resolveFromList(records, groupRef);
-  if (!group.isGroup) throw new GatewayError(`"${group.name}" is a bot, not a group.`);
-  const memberAgentIds = normalizeMemberIds(records, memberRefs);
-  const data = await gatewayCall(session, "setGroupMembers", {
-    id: group.id,
-    memberAgentIds,
-  });
-  return unwrapOne(data) || { ...group, memberIds: memberAgentIds, isGroup: true };
-}
-
-export async function addGroupMember(session, groupRef, memberRef) {
-  const records = await listAgents(session);
-  const group = resolveFromList(records, groupRef);
-  if (!group.isGroup) throw new GatewayError(`"${group.name}" is a bot, not a group.`);
-  const member = resolveFromList(records, memberRef);
-  const next = [...new Set([...group.memberIds, member.id])];
-  return setGroupMembers(session, group.id, next);
-}
-
-export async function removeGroupMember(session, groupRef, memberRef) {
-  const records = await listAgents(session);
-  const group = resolveFromList(records, groupRef);
-  if (!group.isGroup) throw new GatewayError(`"${group.name}" is a bot, not a group.`);
-  const member = resolveFromList(records, memberRef);
-  const next = group.memberIds.filter((id) => id !== member.id);
-  return setGroupMembers(session, group.id, next);
-}
-
-export async function sendPrompt(session, ref, prompt, extra = {}) {
-  const rec = await resolveRef(session, ref);
-  const body = {
-    agentId: rec.id,
-    prompt,
-    clientNonce: extra.clientNonce || randomUUID(),
-  };
-  if (extra.replyToId) body.replyToId = extra.replyToId;
-  let data;
-  try {
-    data = await gatewayCall(session, "sendPrompt", body);
-  } catch (err) {
-    // Delivery states: the server answered no (rejected) vs the request may have landed (unknown).
-    // Never retry an unknown delivery blindly; read the thread first.
-    if (err && err.delivery == null) {
-      err.delivery = err instanceof GatewayError && err.status != null && err.status < 500 ? "rejected" : "unknown";
-    }
-    if (err && err.targetId == null) err.targetId = rec.id;
-    if (err && err.delivery === "unknown" && err instanceof Error && !/delivery unknown/.test(err.message)) {
-      err.message += " (delivery unknown; check the thread before resending)";
-    }
-    throw err;
-  }
-  const messageId = data && typeof data.messageId === "string" ? data.messageId : null;
-  return { target: rec, result: data, delivery: "accepted", ...(messageId ? { messageId } : {}) };
-}
-
-export async function getTranscriptTail(session, ref, limit = 40) {
-  const rec = await resolveRef(session, ref);
-  const bounded = Math.min(Math.max(Math.trunc(limit) || 40, 1), 200);
-  const data = await gatewayCall(session, "getAgentTranscriptTail", { id: rec.id, limit: bounded });
-  return { target: rec, transcript: data };
-}
-
-export async function getThread(session, ref, rootId) {
-  const rec = await resolveRef(session, ref);
-  const data = await gatewayCall(session, "getAgentThread", { id: rec.id, rootId });
-  return { target: rec, thread: data };
-}

package/src/headers.js

@@ -1,53 +0,0 @@
-export function normalizeHeaderMap(obj) {
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return {};
-  const out = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value == null || value === "") continue;
-    out[String(key).toLowerCase()] = String(value);
-  }
-  return out;
-}
-
-export function parseGatewayHeaders(raw) {
-  if (raw == null || String(raw).trim() === "") return {};
-  const parsed = JSON.parse(String(raw));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("GROK_BOT_GATEWAY_HEADERS must be a JSON object");
-  }
-  return normalizeHeaderMap(parsed);
-}
-
-export function headersFromEnsureSandbox(body) {
-  if (!body || typeof body !== "object") return {};
-  const mapped = normalizeHeaderMap(body.gatewayHeaders || body.gateway_headers);
-  if (Object.keys(mapped).length) return mapped;
-  const token = body.anyrunNetworkToken || body.anyrun_network_token || body.networkToken;
-  return token ? { "x-anyrun-network-token": String(token) } : {};
-}
-
-export function headersFromEnv() {
-  return parseGatewayHeaders(process.env.GROK_BOT_GATEWAY_HEADERS);
-}
-
-export function mergeGatewayHeaders(sessionHeaders, envHeaders) {
-  return { ...(sessionHeaders || {}), ...(envHeaders || {}) };
-}
-
-export function requestHeaders(session) {
-  return {
-    "content-type": "application/json",
-    authorization: "Bearer " + session.gatewayToken,
-    ...(session.gatewayHeaders || {}),
-  };
-}
-
-export function ensureSandboxHeaders(accessToken) {
-  return {
-    "content-type": "application/json",
-    "connect-protocol-version": "1",
-    authorization: "Bearer " + accessToken,
-    "x-cursor-client-type": "sand",
-    "x-cursor-client-version": process.env.SAND_CLIENT_VERSION || "0.20.0",
-    "x-sand-box-namespace": process.env.SAND_BOX_NAMESPACE || "prod",
-  };
-}

package/src/history.js

@@ -1,83 +0,0 @@
-import { appendFileSync, closeSync, constants, createReadStream, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { createInterface } from "node:readline";
-import { entryText, transcriptEntries } from "./transcript.js";
-
-export function historyPath(dir) {
-  return join(resolve(dir || process.env.GROK_BOT_HISTORY_DIR || join(homedir(), ".grok-bot-cli")), "history.jsonl");
-}
-
-// Keep only conversation fields, never gateway responses, session credentials or bot instructions.
-export function saveHistory(out, { dir, disabled, event, prompt, rootId } = {}) {
-  // Opt-in only: plaintext local history stays off unless GROK_BOT_HISTORY=on (or true/1).
-  if (disabled || !/^(on|true|1)$/i.test(process.env.GROK_BOT_HISTORY || "")) return;
-  try {
-    const recordedAt = new Date().toISOString();
-    const target = { id: out.target.id, name: out.target.name, kind: out.target.isGroup ? "group" : "bot" };
-    const payload = out.transcript || out.thread || out;
-    const entries = event === "send" ? [{ role: "user", text: prompt }] : transcriptEntries(payload);
-    const rows = entries.map((entry) => ({
-      version: 1,
-      recordedAt,
-      event,
-      target,
-      ...(rootId ? { rootId } : {}),
-      role: String(entry.role || entry.kind || entry.sender || entry.type || "msg"),
-      ...(entry.id || entry.messageId ? { messageId: String(entry.id || entry.messageId) } : {}),
-      ...(entry.timestamp || entry.createdAt ? { timestamp: String(entry.timestamp || entry.createdAt) } : {}),
-      text: entryText(entry),
-    }));
-    if (!rows.length) return;
-    const path = historyPath(dir);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const fd = openSync(path, constants.O_CREAT | constants.O_APPEND | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
-    try {
-      // Separate a previous interrupted append from the next complete record.
-      const size = fstatSync(fd).size;
-      const last = Buffer.alloc(1);
-      if (size) readSync(fd, last, 0, 1, size - 1);
-      const prefix = size && last[0] !== 10 ? "\n" : "";
-      appendFileSync(fd, prefix + rows.map((row) => JSON.stringify(row)).join("\n") + "\n");
-    } finally {
-      closeSync(fd);
-    }
-  } catch {
-    // A successful remote send must not look failed and invite an accidental resend.
-    process.stderr.write("Warning: could not save local history. Check the history directory and permissions.\n");
-  }
-}
-
-export async function readHistory(path, { ref, search, limit = 40 } = {}) {
-  const rows = [];
-  let malformed = 0;
-  const input = createReadStream(path, { encoding: "utf8" });
-  const lines = createInterface({ input, crlfDelay: Infinity });
-  try {
-    for await (const line of lines) {
-      if (!line.trim()) continue;
-      let row;
-      try {
-        row = JSON.parse(line);
-        if (row?.version !== 1 || typeof row.text !== "string" || typeof row.role !== "string" ||
-            typeof row.recordedAt !== "string" || typeof row.target?.id !== "string" || typeof row.target?.name !== "string") {
-          throw new Error("Invalid history record");
-        }
-      } catch {
-        malformed++;
-        continue;
-      }
-      if (ref && row.target.id !== ref && row.target.name.toLowerCase() !== ref.toLowerCase()) continue;
-      if (search !== undefined && !row.text.toLowerCase().includes(search.toLowerCase())) continue;
-      rows.push(row);
-      if (rows.length > limit) rows.shift();
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  } finally {
-    lines.close();
-    input.destroy();
-  }
-  if (malformed) process.stderr.write("Warning: skipped " + malformed + " malformed local history record(s).\n");
-  return rows;
-}