@aiwg/cli 2026.10.1 → 2026.10.4

package/dist/src/sessions/adapters/grok-build.js

@@ -1,5 +1,5 @@
 import { basename, extname } from 'node:path';
-import { SessionContractError, } from '../contracts.js';
+import { SessionContractError, schemaIssueDetail, } from '../contracts.js';
 import { readBoundedText } from '../readers.js';
 export const GROK_BUILD_ADAPTER_VERSION = '1.0.0';
 export const GROK_BUILD_CLI_EXPORT_SCHEMA_VERSION = '1.0.0';
@@ -75,7 +75,7 @@ export class GrokBuildSessionAdapter {
         }
         const filename = basename(source.locator, extname(source.locator));
         if (extname(source.locator).toLowerCase() !== '.md' || !UUID.test(filename)) {
-            throw new SessionContractError('MALFORMED_SOURCE', 'Grok Build export filename must be <session-id>.md so the documented CLI session ID is preserved.');
+            throw new SessionContractError('MALFORMED_SOURCE', 'Grok Build export filename must be <session-id>.md so the documented CLI session ID is preserved.', schemaIssueDetail('filename'));
         }
         const { value } = await readBoundedText({
             selectedPath: source.locator,
@@ -93,7 +93,7 @@ export function validateGrokBuildMarkdown(value) {
             parseTools(block.text, sequence);
     }
     if (blocks.length === 0 || !blocks.some((block) => block.heading === 'User')) {
-        throw new SessionContractError('MALFORMED_SOURCE', 'Unrecognized Grok Build CLI export; expected exact `## User`, `## Assistant`, or `## Tools` headings.');
+        throw new SessionContractError('MALFORMED_SOURCE', 'Unrecognized Grok Build CLI export; expected exact `## User`, `## Assistant`, or `## Tools` headings.', schemaIssueDetail('headings'));
     }
     return blocks;
 }
@@ -105,7 +105,7 @@ function parseBlocks(value) {
             return;
         const text = current.lines.join('\n').trim();
         if (!text && current.heading === 'Tools') {
-            throw new SessionContractError('SCHEMA_DRIFT', 'Grok Build tools block is empty');
+            throw new SessionContractError('SCHEMA_DRIFT', 'Grok Build tools block is empty', schemaIssueDetail('tools'));
         }
         if (text)
             blocks.push({ heading: current.heading, text });
@@ -117,13 +117,13 @@ function parseBlocks(value) {
             current = { heading: match[1], lines: [] };
         }
         else if (/^##\s+/.test(line)) {
-            throw new SessionContractError('SCHEMA_DRIFT', `unknown Grok Build CLI export heading: ${line}`);
+            throw new SessionContractError('SCHEMA_DRIFT', `unknown Grok Build CLI export heading: ${line}`, schemaIssueDetail('headings'));
         }
         else if (current) {
             current.lines.push(line);
         }
         else if (line.trim()) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'unexpected content before the first Grok Build CLI export heading');
+            throw new SessionContractError('SCHEMA_DRIFT', 'unexpected content before the first Grok Build CLI export heading', schemaIssueDetail('headings'));
         }
     }
     flush();
@@ -132,17 +132,17 @@ function parseBlocks(value) {
 function parseTools(text, blockSequence) {
     const lines = text.split('\n').filter((line) => line.trim());
     if (lines.length === 0 || lines.length > 1_000) {
-        throw new SessionContractError('SCHEMA_DRIFT', 'Grok Build tools block has no summaries or exceeds 1,000 summaries');
+        throw new SessionContractError('SCHEMA_DRIFT', 'Grok Build tools block has no summaries or exceeds 1,000 summaries', schemaIssueDetail('tools'));
     }
     return lines.map((line, index) => {
         const match = /^- (.+)$/.exec(line);
         if (!match) {
-            throw new SessionContractError('SCHEMA_DRIFT', `unrecognized Grok Build tool summary: ${line}`);
+            throw new SessionContractError('SCHEMA_DRIFT', `unrecognized Grok Build tool summary: ${line}`, schemaIssueDetail('tools'));
         }
         const summary = match[1];
         const name = summary.split(/:| \(/, 1)[0]?.trim();
         if (!name) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'empty Grok Build tool summary');
+            throw new SessionContractError('SCHEMA_DRIFT', 'empty Grok Build tool summary', schemaIssueDetail('tools'));
         }
         return { sequence: blockSequence * 1_000 + index, name, text: summary };
     });
@@ -176,11 +176,11 @@ function parseCursor(value) {
     if (!value)
         return 0;
     if (!/^\d+$/.test(value)) {
-        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Grok Build export cursor');
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Grok Build export cursor', schemaIssueDetail('cursor'));
     }
     const cursor = Number(value);
     if (!Number.isSafeInteger(cursor)) {
-        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Grok Build export cursor');
+        throw new SessionContractError('SCHEMA_DRIFT', 'invalid Grok Build export cursor', schemaIssueDetail('cursor'));
     }
     return cursor;
 }

package/dist/src/sessions/adapters/grokbot-locator.js

@@ -0,0 +1,111 @@
+/**
+ * Grok Bot desktop native-store locator primitives (#2970).
+ *
+ * The Grok Bot desktop app ("sand") persists one JSON document per logical
+ * key under `$XDG_CONFIG_HOME/Grok Bot/sand-client-persistence/` (default
+ * `~/.config/Grok Bot/...`, Linux only — macOS/Windows equivalents are
+ * unverified and must never be guessed). Each file is named `<key>.blob`,
+ * where `<key>` is the RFC 4648 section 6 base32 encoding of the key string,
+ * lowercase, unpadded.
+ *
+ * This module decodes filenames ONLY — it never opens file content. The
+ * adapter layer uses {@link classifyGrokbotBlobName} to build a strict
+ * allowlist: only filenames that decode to a transcript-replica or
+ * last-roster key are ever candidates for opening. Every other `.blob` file
+ * (composer drafts, send journal, experiments, UI layout, secrets, cookies,
+ * local/session storage, etc.) is left untouched.
+ *
+ * @see docs/providers/grokbot-sessions.md
+ * @issue #2970
+ */
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const BASE32_INDEX = new Map(BASE32_ALPHABET.split('').map((char, index) => [char, index]));
+const BASE32_SHAPE = /^[a-z2-7]+$/;
+const TRANSCRIPT_REPLICA_KEY_PATTERN = /^sand\.client\.slice\.account\.grok%7Cuser_[^.]+\.transcript\.replicas\.([0-9a-fA-F-]{36})$/;
+const ROSTER_KEY_PATTERN = /^sand\.client\.slice\.account\.grok%7Cuser_[^.]+\.roster\.last-roster$/;
+/** Unpadded lowercase RFC 4648 base32 encode, most significant bit first. */
+export function encodeGrokbotKey(key) {
+    const bytes = Buffer.from(key, 'utf8');
+    let bits = 0;
+    let value = 0;
+    let out = '';
+    for (const byte of bytes) {
+        value = ((value << 8) | byte) & 0xffff;
+        bits += 8;
+        while (bits >= 5) {
+            out += BASE32_ALPHABET[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0)
+        out += BASE32_ALPHABET[(value << (5 - bits)) & 31];
+    return out;
+}
+/**
+ * Decode an unpadded lowercase RFC 4648 base32 string back to its original
+ * UTF-8 key. Returns null for anything that is not canonical base32 (wrong
+ * alphabet, or non-zero padding bits) rather than guessing.
+ */
+export function decodeGrokbotKey(encoded) {
+    if (encoded.length === 0 || !BASE32_SHAPE.test(encoded))
+        return null;
+    const bytes = [];
+    let buffer = 0;
+    let bitsLeft = 0;
+    for (const char of encoded) {
+        const index = BASE32_INDEX.get(char);
+        if (index === undefined)
+            return null;
+        buffer = (buffer << 5) | index;
+        bitsLeft += 5;
+        if (bitsLeft >= 8) {
+            bitsLeft -= 8;
+            bytes.push((buffer >> bitsLeft) & 0xff);
+        }
+    }
+    if (bitsLeft >= 5)
+        return null;
+    if (bitsLeft > 0 && (buffer & ((1 << bitsLeft) - 1)) !== 0)
+        return null;
+    try {
+        return Buffer.from(bytes).toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Classify a `<base32>.blob` filename WITHOUT opening it. Returns null for
+ * anything that is not a `.blob` file, does not decode to canonical base32,
+ * or decodes to a key outside the allowlist (composer drafts, send journal,
+ * experiments, ui-layout, secrets, cookies, storage, etc.).
+ */
+export function classifyGrokbotBlobName(filename) {
+    if (!filename.endsWith('.blob'))
+        return null;
+    const encoded = filename.slice(0, -'.blob'.length);
+    const key = decodeGrokbotKey(encoded);
+    if (key === null)
+        return null;
+    const transcript = TRANSCRIPT_REPLICA_KEY_PATTERN.exec(key);
+    if (transcript)
+        return { kind: 'transcript-replica', conversationId: transcript[1] };
+    if (ROSTER_KEY_PATTERN.test(key))
+        return { kind: 'roster' };
+    return null;
+}
+/** Build the `<key>.blob` filename for a transcript replica (test fixtures only). */
+export function grokbotTranscriptReplicaFilename(account, conversationId) {
+    return `${encodeGrokbotKey(`sand.client.slice.account.grok%7Cuser_${account}.transcript.replicas.${conversationId}`)}.blob`;
+}
+/** Build the `<key>.blob` filename for the account roster (test fixtures only). */
+export function grokbotRosterFilename(account) {
+    return `${encodeGrokbotKey(`sand.client.slice.account.grok%7Cuser_${account}.roster.last-roster`)}.blob`;
+}
+/** Extract the conversation id from an authorized transcript-replica locator path, or null. */
+export function grokbotConversationIdFromLocator(locator) {
+    const base = locator.replaceAll('\\', '/').split('/').pop() ?? '';
+    const classification = classifyGrokbotBlobName(base);
+    return classification?.kind === 'transcript-replica' ? classification.conversationId : null;
+}
+//# sourceMappingURL=grokbot-locator.js.map