grok-bot-cli 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "CLI for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "bin": {
@@ -43,6 +43,6 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@changesets/cli": "2.31.1"
+    "@changesets/cli": "3.0.1"
   }
 }

package/src/app-session.js

@@ -6,6 +6,49 @@ import { join } from "node:path";
 
 const SAFE_STORAGE_PREFIX = Buffer.from("v10");
 
+export class GrokBotGatewaySessionError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "GrokBotGatewaySessionError";
+    this.code = code;
+  }
+}
+
+function encryptedPayload(wrapped) {
+  if (wrapped.version != null && wrapped.version !== 1 && wrapped.version !== 2) {
+    throw new GrokBotGatewaySessionError(
+      "UNSUPPORTED_VERSION",
+      `Unsupported Grok Bot gateway descriptor version ${wrapped.version}.`,
+    );
+  }
+  let encrypted;
+  if (wrapped.version === 2) {
+    const entries = Object.values(wrapped.entries ?? {});
+    if (entries.length === 0) {
+      throw new GrokBotGatewaySessionError(
+        "EMPTY_ENTRIES",
+        "Grok Bot gateway descriptor has no saved gateway entries.",
+      );
+    }
+    if (entries.length > 1) {
+      throw new GrokBotGatewaySessionError(
+        "AMBIGUOUS_ENTRIES",
+        "Grok Bot gateway descriptor has multiple saved gateway entries and no active entry selection.",
+      );
+    }
+    encrypted = entries[0]?.encrypted;
+  } else {
+    encrypted = wrapped.encrypted;
+  }
+  if (typeof encrypted !== "string" || !encrypted) {
+    throw new GrokBotGatewaySessionError(
+      "MISSING_ENCRYPTED_PAYLOAD",
+      "Grok Bot gateway descriptor is missing an encrypted payload.",
+    );
+  }
+  return encrypted;
+}
+
 export function decryptSafeStorageString(encryptedBase64, password) {
   const encrypted = Buffer.from(encryptedBase64, "base64");
   if (!encrypted.subarray(0, 3).equals(SAFE_STORAGE_PREFIX)) {
@@ -57,13 +100,17 @@ export function loadGrokBotGatewaySession({
   if (!existsSync(path)) return null;
 
   const wrapped = JSON.parse(readFileSync(path, "utf8"));
+  const encrypted = encryptedPayload(wrapped);
   const clear = decryptSafeStorageString(
-    wrapped.encrypted,
+    encrypted,
     getKeychainPassword(),
   );
   const descriptor = JSON.parse(clear);
   if (!descriptor.baseUrl || !descriptor.token) {
-    throw new Error("Grok Bot gateway descriptor is incomplete.");
+    throw new GrokBotGatewaySessionError(
+      "INCOMPLETE_DESCRIPTOR",
+      "Decrypted Grok Bot gateway descriptor is incomplete.",
+    );
   }
 
   return {
@@ -72,3 +119,20 @@ export function loadGrokBotGatewaySession({
     headers: descriptor.headers ?? {},
   };
 }
+
+export function inspectGrokBotGatewaySession(options = {}) {
+  if (!hasGrokBotGatewaySession(options)) {
+    return { present: false, usable: false };
+  }
+  try {
+    loadGrokBotGatewaySession(options);
+    return { present: true, usable: true };
+  } catch (error) {
+    return {
+      present: true,
+      usable: false,
+      code: error instanceof GrokBotGatewaySessionError ? error.code : "UNUSABLE_SESSION",
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/cli.js

@@ -2,6 +2,7 @@
 import { AVATAR_COLORS, AVATAR_SHAPES, MAX_GROUP_MEMBERS, StoreError, defaultCandidateRoots, looksLikeAgentsRoot, resolveAgentsRoot } from "./store.js";
 import { hasGatewayAuth } from "./gateway.js";
 import { openBackend } from "./commands.js";
+import { inspectGrokBotGatewaySession } from "./app-session.js";
 
 function print(value) {
   if (typeof value === "string") process.stdout.write(value + "\n");
@@ -247,11 +248,16 @@ async function main(argv) {
       if (!(err instanceof StoreError)) throw err;
     }
     const note = "Live roster is on the box. Prefer CURSOR_ACCESS_TOKEN then EnsureSandBox then POST gateway /api/*.";
-    const payload = { resolved, found, candidates, gatewayAuthPresent: hasGatewayAuth(), note };
+    const gatewayAuthPresent = hasGatewayAuth();
+    const grokBotAppSession = inspectGrokBotGatewaySession();
+    const payload = { resolved, found, candidates, gatewayAuthPresent, grokBotAppSession, note };
     if (json) print(payload);
     else {
       print("resolved: " + (resolved ?? "(none)"));
-      print("gateway auth: " + (hasGatewayAuth() ? "yes (env)" : "no"));
+      print("gateway auth: " + (gatewayAuthPresent ? "present" : "no"));
+      if (grokBotAppSession.usable) print("Grok Bot app session: usable");
+      else if (grokBotAppSession.present) print("Grok Bot app session: present but unusable: " + grokBotAppSession.error);
+      else print("Grok Bot app session: not found");
       print("found:");
       print(found.length ? found.map((p) => "  " + p).join("\n") : "  (none)");
       print("candidates:");

package/src/store.js

@@ -235,9 +235,8 @@ function writeGroup(dir, memberIds) {
   });
 }
 
-function normalizeMemberIds(root, memberRefs, { groupId } = {}) {
+function normalizeMemberIds(root, memberRefs) {
   const records = listRecords(root);
-  const byId = new Map(records.map((r) => [r.id, r]));
   const groups = new Set(records.filter((r) => r.isGroup).map((r) => r.id));
   const resolved = [];
   const seen = new Set();
@@ -246,8 +245,6 @@ function normalizeMemberIds(root, memberRefs, { groupId } = {}) {
     if (groups.has(rec.id)) {
       throw new StoreError(`Cannot add group "${rec.name}" as a member. Nested groups are not allowed.`);
     }
-    if (groupId && rec.id === groupId) continue;
-    if (!byId.has(rec.id)) continue;
     if (seen.has(rec.id)) continue;
     seen.add(rec.id);
     resolved.push(rec.id);
@@ -341,7 +338,7 @@ export function createGroup(root, input) {
 export function setGroupMembers(root, groupRef, memberRefs) {
   const group = resolveRef(root, groupRef);
   if (!group.isGroup) throw new StoreError(`"${group.name}" is a bot, not a group.`);
-  const memberIds = normalizeMemberIds(root, memberRefs, { groupId: group.id });
+  const memberIds = normalizeMemberIds(root, memberRefs);
   if (memberIds.length === 0) {
     throw new StoreError("A group needs at least one existing member agent.");
   }