@aiwg/cli 2026.10.1 → 2026.10.3

package/dist/src/sessions/adapter-registry.js

@@ -0,0 +1,45 @@
+import { ClaudeSessionAdapter } from './adapters/claude.js';
+import { CodexSessionAdapter } from './adapters/codex.js';
+import { CopilotSessionAdapter } from './adapters/copilot.js';
+import { CursorSessionAdapter } from './adapters/cursor.js';
+import { FactorySessionAdapter } from './adapters/factory.js';
+import { HermesSessionAdapter } from './adapters/hermes.js';
+import { OpenCodeSessionAdapter } from './adapters/opencode.js';
+import { OpenClawSessionAdapter } from './adapters/openclaw.js';
+import { OpenHumanSessionAdapter } from './adapters/openhuman.js';
+import { GrokbotSessionAdapter } from './adapters/grokbot.js';
+import { GrokBuildSessionAdapter } from './adapters/grok-build.js';
+import { MuseSessionAdapter } from './adapters/muse.js';
+import { PiSessionAdapter } from './adapters/pi.js';
+import { OmpSessionAdapter } from './adapters/omp.js';
+import { DeepSeekHarnessSessionAdapter } from './adapters/deepseek-harness.js';
+import { WarpSessionAdapter } from './adapters/warp.js';
+import { DevinDesktopSessionAdapter } from './adapters/windsurf.js';
+import { GenericSessionInterchangeAdapter } from './adapters/generic.js';
+import { SessionSourceAdapterRegistry } from './discovery.js';
+export function createSessionAdapterRegistry() {
+    const registry = new SessionSourceAdapterRegistry();
+    for (const adapter of [
+        new ClaudeSessionAdapter(),
+        new CodexSessionAdapter(),
+        new CopilotSessionAdapter(),
+        new CursorSessionAdapter(),
+        new FactorySessionAdapter(),
+        new HermesSessionAdapter(),
+        new OpenCodeSessionAdapter(),
+        new OpenClawSessionAdapter(),
+        new OpenHumanSessionAdapter(),
+        new GrokbotSessionAdapter(),
+        new GrokBuildSessionAdapter(),
+        new MuseSessionAdapter(),
+        new PiSessionAdapter(),
+        new OmpSessionAdapter(),
+        new DeepSeekHarnessSessionAdapter(),
+        new WarpSessionAdapter(),
+        new DevinDesktopSessionAdapter(),
+        new GenericSessionInterchangeAdapter(),
+    ])
+        registry.register(adapter);
+    return registry;
+}
+//# sourceMappingURL=adapter-registry.js.map

package/dist/src/sessions/adapters/generic.js

@@ -88,6 +88,7 @@ export class GenericSessionInterchangeAdapter {
             sourceSchemaVersion: header.schemaVersion,
             consistency: header.consistency,
             operationalState: 'available',
+            declaredWorkspaceId: header.workspace.id,
         };
     }
     async *stream(source, cursor) {
@@ -179,7 +180,10 @@ export class GenericSessionInterchangeAdapter {
         const header = parseHeader(value);
         assertSupportedSchemaMajor(header.schemaVersion);
         if (header.sourceId !== source.sourceId) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'selected source identity does not match interchange header');
+            // SCHEMA_DRIFT: the selected identity no longer describes this file's
+            // declared source, so importing it would attach events to the wrong source.
+            throw new SessionContractError('SCHEMA_DRIFT', `selected source identity does not match interchange header: --source-id ${quoteValue(source.sourceId)} `
+                + `but header sourceId is ${quoteValue(header.sourceId)}; pass --source-id ${quoteValue(header.sourceId)}`);
         }
         return header;
     }
@@ -200,7 +204,10 @@ function parseHeader(value) {
     if (hasAmbiguousTimestamp(result.error)) {
         throw new SessionContractError('AMBIGUOUS_TIMESTAMP', 'generic interchange header has an ambiguous timestamp');
     }
-    throw new SessionContractError('MALFORMED_SOURCE', 'input is not a declared AIWG generic session interchange');
+    if (!isDeclaredInterchange(value)) {
+        throw new SessionContractError('MALFORMED_SOURCE', 'input is not a declared AIWG generic session interchange');
+    }
+    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange header ${describeIssue(result.error, true)}`);
 }
 function parseEvent(value) {
     const result = GenericInterchangeEventSchema.safeParse(value);
@@ -209,7 +216,34 @@ function parseEvent(value) {
     if (hasAmbiguousTimestamp(result.error)) {
         throw new SessionContractError('AMBIGUOUS_TIMESTAMP', 'generic interchange event has an ambiguous timestamp');
     }
-    throw new SessionContractError('MALFORMED_SOURCE', 'generic interchange event is malformed');
+    // Event values can carry transcript content, so name the field and the
+    // expected shape without echoing the received value.
+    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange event is malformed: ${describeIssue(result.error, false)}`);
+}
+function isDeclaredInterchange(value) {
+    return typeof value === 'object' && value !== null
+        && value.type === GENERIC_INTERCHANGE_KIND;
+}
+function quoteValue(value) {
+    const text = typeof value === 'string' ? value : JSON.stringify(value) ?? String(value);
+    return JSON.stringify(text.length > 64 ? `${text.slice(0, 64)}…` : text);
+}
+function describeIssue(error, echoReceived) {
+    const issue = error.issues[0];
+    const field = issue.path.length > 0 ? `field "${issue.path.join('.')}"` : 'record';
+    if (issue.code === z.ZodIssueCode.invalid_enum_value) {
+        const received = echoReceived ? ` (got ${quoteValue(issue.received)})` : '';
+        return `${field} must be one of ${issue.options.join('|')}${received}`;
+    }
+    if (issue.code === z.ZodIssueCode.invalid_type) {
+        return issue.received === 'undefined'
+            ? `${field} is required (${issue.expected})`
+            : `${field} must be ${issue.expected} (got ${issue.received})`;
+    }
+    if (issue.code === z.ZodIssueCode.invalid_literal) {
+        return `${field} must be ${quoteValue(issue.expected)}`;
+    }
+    return `${field} is invalid: ${issue.message}`;
 }
 function hasAmbiguousTimestamp(error) {
     return error.issues.some((issue) => issue.code === z.ZodIssueCode.custom

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