grok-bot-cli 0.10.2 → 0.11.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "CLI and Agent Bundle plugin for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "engines": {

package/dist/plugin.json

@@ -1 +1 @@
-{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","author":{"name":"Zack Jackson","url":"https://github.com/ScriptedAlchemy"},"description":"Message Grok Bot from Codex, Claude Code, and Cursor. Codex/Claude tools use local sockets on the user's registered machines only (no remote transport); from the Grok Bot box, run gbot via Grok Bot Shell with a machineId.","homepage":"https://github.com/ScriptedAlchemy/grok-bot-cli#readme","keywords":["grok","grok-bot","grokbot","gbot","cursor","ai-agents","automation","terminal","cli","agent-bundle"],"license":"MIT","name":"gbot","repository":"https://github.com/ScriptedAlchemy/grok-bot-cli","version":"0.10.2"}
+{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","author":{"name":"Zack Jackson","url":"https://github.com/ScriptedAlchemy"},"description":"Message Grok Bot from Codex, Claude Code, and Cursor. Codex/Claude tools use local sockets on the user's registered machines only (no remote transport); from the Grok Bot box, run gbot via Grok Bot Shell with a machineId.","homepage":"https://github.com/ScriptedAlchemy/grok-bot-cli#readme","keywords":["grok","grok-bot","grokbot","gbot","cursor","ai-agents","automation","terminal","cli","agent-bundle"],"license":"MIT","name":"gbot","repository":"https://github.com/ScriptedAlchemy/grok-bot-cli","version":"0.11.0"}

package/dist/scripts/gbot-relay.mjs

@@ -22133,8 +22133,10 @@ var __webpack_modules__ = {
         var node_child_process__rspack_import_5 = __webpack_require__("node:child_process");
         var _package_json__rspack_import_6 = __webpack_require__("./package.json");
         var _codex_contract_js__rspack_import_7 = __webpack_require__("./src/core/codex/contract.js");
-        var _desktop_shim_js__rspack_import_8 = __webpack_require__("./src/core/desktop-shim.js");
-        var _user_machine_guidance_js__rspack_import_9 = __webpack_require__("./src/core/user-machine-guidance.js");
+        var _codex_remote_control_js__rspack_import_8 = __webpack_require__("./src/core/codex/remote-control.js");
+        var _codex_thread_id_js__rspack_import_11 = __webpack_require__("./src/core/codex/thread-id.js");
+        var _desktop_shim_js__rspack_import_9 = __webpack_require__("./src/core/desktop-shim.js");
+        var _user_machine_guidance_js__rspack_import_10 = __webpack_require__("./src/core/user-machine-guidance.js");
         const PINNED_CODEX_VERSION = "0.158.0";
         const UPSTREAM_DESKTOP_ISSUES = [
             "https://github.com/openai/codex/issues/41014",
@@ -22142,8 +22144,9 @@ var __webpack_modules__ = {
         ];
         const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
         const WS_MAX_HEADER_BYTES = 16 * 1024;
-        const WS_MAX_MESSAGE_BYTES = 4 * 1024 * 1024;
-        const WS_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+        const WS_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+        const WS_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+        const CODEX_SEND_MAX_BYTES = 4 * 1024 * 1024;
         const WS_MAX_WRITE_BYTES = 8 * 1024 * 1024;
         const CODEX_MAX_REQUESTS = 128;
         const CODEX_MAX_LISTENERS = 128;
@@ -22171,11 +22174,11 @@ var __webpack_modules__ = {
         function boxUnreachableMessage(path) {
             return [
                 "No Codex app-server control socket at " + path + ".",
-                _user_machine_guidance_js__rspack_import_9.M
+                _user_machine_guidance_js__rspack_import_10.M
             ].join("\n");
         }
         function unreachableMessage(path, desktopAttached = "unknown", env = process.env) {
-            if ((0, _user_machine_guidance_js__rspack_import_9.R)({
+            if ((0, _user_machine_guidance_js__rspack_import_10.R)({
                 path,
                 env,
                 home: env.HOME || (0, node_os__rspack_import_3.homedir)()
@@ -23014,6 +23017,13 @@ var __webpack_modules__ = {
             if (value == null) return null;
             return typeof value === "string" ? singleLine(value) : value;
         }
+        function summarizeSection(section) {
+            if (!isObject(section) || typeof section.id !== "string" || !section.id) return null;
+            return {
+                id: singleLine(section.id),
+                name: lineField(section.name)
+            };
+        }
         function summarizeThread(t) {
             if (!isObject(t) || typeof t.id !== "string" || !t.id) throw new CodexProtocolError("thread/list", "entry without a string `id`");
             const type = isObject(t.status) && typeof t.status.type === "string" ? t.status.type : "unknown";
@@ -23025,43 +23035,72 @@ var __webpack_modules__ = {
                 preview: typeof t.preview === "string" ? stripTerminalControls(t.preview) : "",
                 cwd: lineField(t.cwd),
                 source: sourceField(t.source),
-                updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : null
+                createdAt: typeof t.createdAt === "number" ? t.createdAt : null,
+                updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : null,
+                section: summarizeSection(t.section),
+                projectId: lineField(t.projectId),
+                modelProvider: lineField(t.modelProvider),
+                model: lineField(t.model),
+                originator: lineField(t.originator)
             };
         }
         const THREAD_LIST_MAX_LIMIT = 200;
-        async function listCodexThreads({ limit = 20, cursor, env = process.env } = {}) {
+        async function listCodexThreads({ limit = 20, cursor, modelProviders = [], env = process.env } = {}) {
             if (!Number.isInteger(limit) || limit < 1 || limit > THREAD_LIST_MAX_LIMIT) {
                 throw new RangeError("--limit must be an integer 1-" + THREAD_LIST_MAX_LIMIT);
             }
             if (cursor !== undefined && (typeof cursor !== "string" || !cursor)) throw new RangeError("--cursor must be a non-empty string");
+            if (!Array.isArray(modelProviders) || modelProviders.some((p)=>typeof p !== "string")) {
+                throw new RangeError("modelProviders must be an array of strings (empty = all providers)");
+            }
             const { client } = await openSession(env);
             try {
-                const params = {
+                const baseParams = {
                     limit,
-                    useStateDbOnly: true,
+                    modelProviders,
                     ...cursor !== undefined ? {
                         cursor
                     } : {}
                 };
                 let out;
+                let usedStateDbOnly = true;
                 try {
-                    out = await client.request("thread/list", params);
+                    out = await client.request("thread/list", {
+                        ...baseParams,
+                        useStateDbOnly: true
+                    });
                 } catch (err) {
                     throw transportError(err);
                 }
                 if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/list", "missing `data` array");
+                if (out.data.length === 0 && cursor === undefined && (out.nextCursor == null || out.nextCursor === "")) {
+                    try {
+                        out = await client.request("thread/list", {
+                            ...baseParams,
+                            useStateDbOnly: false
+                        });
+                        usedStateDbOnly = false;
+                    } catch (err) {
+                        throw transportError(err);
+                    }
+                    if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/list", "missing `data` array");
+                }
                 if (out.nextCursor != null && typeof out.nextCursor !== "string") throw new CodexProtocolError("thread/list", "`nextCursor` is not a string");
                 const threads = out.data.map(summarizeThread);
                 return {
                     threads,
                     nextCursor: out.nextCursor ?? null,
-                    limit
+                    limit,
+                    useStateDbOnly: usedStateDbOnly
                 };
             } finally{
                 client.close();
             }
         }
-        function explainSendError(err, threadId) {
+        function explainSendError(err, threadId, env = process.env) {
+            if (err instanceof _codex_remote_control_js__rspack_import_8.Rg) return err;
+            const mapped = (0, _codex_remote_control_js__rspack_import_8.R3)(err, threadId, env);
+            if (mapped instanceof _codex_remote_control_js__rspack_import_8.Rg) return mapped;
             if (!(err instanceof CodexRpcError)) return err;
             const msg = String(err.rpc && err.rpc.message || "");
             if (/no rollout found|thread not found/i.test(msg)) {
@@ -23136,12 +23175,19 @@ var __webpack_modules__ = {
         function assertThreadAllowed(threadId, env = process.env) {
             const raw = env.GROK_BOT_CODEX_THREADS;
             if (raw == null || raw.trim() === "") return;
-            const allowed = raw.split(",").map((s)=>s.trim()).filter(Boolean);
-            if (!allowed.includes(threadId)) {
-                throw new CodexSendError("Codex thread " + threadId + " is not in GROK_BOT_CODEX_THREADS; the operator allows only: " + allowed.join(", "), {
+            const bare = (0, _codex_thread_id_js__rspack_import_11.SX)(threadId);
+            const allowed = raw.split(",").map((s)=>{
+                try {
+                    return (0, _codex_thread_id_js__rspack_import_11.SX)(s.trim());
+                } catch  {
+                    return s.trim();
+                }
+            }).filter(Boolean);
+            if (!allowed.includes(bare)) {
+                throw new CodexSendError("Codex thread " + bare + " is not in GROK_BOT_CODEX_THREADS; the operator allows only: " + allowed.join(", "), {
                     delivery: "rejected",
                     reason: "route-not-allowed",
-                    threadId
+                    threadId: bare
                 });
             }
         }
@@ -23211,6 +23257,7 @@ var __webpack_modules__ = {
         }
         async function listCodexQueue(threadId, { env = process.env, limit = 50, cursor } = {}) {
             requireExperimental(env, "gbot codex queue");
+            threadId = normalizeCodexThreadId(threadId);
             const { client } = await openSession(env, {
                 experimental: true
             });
@@ -23241,6 +23288,64 @@ var __webpack_modules__ = {
                 client.close();
             }
         }
+        async function readCodexThread(threadId, { limit = 100, env = process.env } = {}) {
+            if (!Number.isInteger(limit) || limit < 1 || limit > 2000) {
+                throw new RangeError("limit must be an integer 1-2000");
+            }
+            const bare = normalizeCodexThreadId(threadId);
+            const { client } = await openSession(env);
+            try {
+                let meta;
+                try {
+                    meta = await client.request("thread/read", {
+                        threadId: bare
+                    });
+                } catch (err) {
+                    const mapped = explainSendError(err, bare, env);
+                    if (mapped instanceof RemoteThreadNotLoadedError) throw mapped;
+                    throw transportError(err);
+                }
+                const turns = [];
+                let cursor;
+                const seen = new Set();
+                for(let page = 0; page < 40 && turns.length < limit; page++){
+                    let out;
+                    try {
+                        out = await client.request("thread/turns/list", {
+                            threadId: bare,
+                            limit: Math.min(100, limit - turns.length),
+                            itemsView: "full",
+                            sortDirection: "desc",
+                            ...cursor !== undefined ? {
+                                cursor
+                            } : {}
+                        });
+                    } catch (err) {
+                        const mapped = explainSendError(err, bare, env);
+                        if (mapped instanceof RemoteThreadNotLoadedError) throw mapped;
+                        throw transportError(err);
+                    }
+                    if (!isObject(out) || !Array.isArray(out.data)) {
+                        throw new CodexProtocolError("thread/turns/list", "missing `data` array");
+                    }
+                    for (const row of out.data)turns.push(row);
+                    cursor = out.nextCursor ?? null;
+                    if (cursor === null) break;
+                    if (typeof cursor !== "string" || !cursor || seen.has(cursor)) {
+                        throw new CodexProtocolError("thread/turns/list", "invalid or repeated cursor");
+                    }
+                    seen.add(cursor);
+                }
+                return {
+                    threadId: bare,
+                    thread: isObject(meta) && isObject(meta.thread) ? meta.thread : null,
+                    turns: turns.slice(0, limit),
+                    nextCursor: cursor ?? null
+                };
+            } finally{
+                client.close();
+            }
+        }
         async function sendToCodexThread(threadId, text, { env = process.env, envelope = buildEnvelope({
             env
         }), whenBusy = "reject", session, expectedTurnId, expectedCwd, model, effort, signal } = {}) {
@@ -23286,8 +23391,8 @@ var __webpack_modules__ = {
                 ] : []
             ].includes(whenBusy)) throw new RangeError("--when-busy must be reject, queue, or persistent steer");
             if (whenBusy === "steer" && (typeof expectedTurnId !== "string" || !ID_PATTERN.test(expectedTurnId))) throw new RangeError("steer requires expectedTurnId");
-            if (typeof threadId !== "string" || !ID_PATTERN.test(threadId)) throw new RangeError("Invalid threadId");
-            if (typeof text !== "string" || !text.trim() || Buffer.byteLength(text) > WS_MAX_MESSAGE_BYTES) throw new RangeError("Message must contain text within 4 MiB");
+            threadId = (0, _codex_thread_id_js__rspack_import_11.SX)(threadId);
+            if (typeof text !== "string" || !text.trim() || Buffer.byteLength(text) > CODEX_SEND_MAX_BYTES) throw new RangeError("Message must contain text within 4 MiB");
             if (!envelope || typeof envelope.messageId !== "string" || !ID_PATTERN.test(envelope.messageId)) throw new RangeError("Invalid envelope messageId");
             const validated = buildEnvelope({
                 correlationId: envelope.correlationId,
@@ -23335,8 +23440,10 @@ var __webpack_modules__ = {
                     });
                 } catch (err) {
                     assertNotCancelled();
-                    if (err instanceof CodexSendError) throw err;
-                    throw new CodexSendError(explainSendError(err, threadId).message, {
+                    if (err instanceof CodexSendError || err instanceof _codex_remote_control_js__rspack_import_8.Rg) throw err;
+                    const explained = explainSendError(err, threadId, env);
+                    if (explained instanceof _codex_remote_control_js__rspack_import_8.Rg) throw explained;
+                    throw new CodexSendError(explained.message, {
                         delivery: err instanceof CodexRpcError ? "rejected" : err && err.delivery || "unknown",
                         reason: err instanceof CodexRpcError ? /no rollout found|thread not found/i.test(String(err.rpc && err.rpc.message)) ? "unknown-thread" : /active writer/i.test(String(err.rpc && err.rpc.message)) ? "external-owner" : "rejected" : "transport",
                         threadId,
@@ -23567,7 +23674,11 @@ var __webpack_modules__ = {
                     "messageId",
                     "correlationId",
                     "refused",
-                    "hop"
+                    "hop",
+                    "hostId",
+                    "hostName",
+                    "hint",
+                    "code"
                 ]){
                     if (error[key] !== undefined) out[key] = error[key];
                 }
@@ -23602,9 +23713,12 @@ var __webpack_modules__ = {
         var _contract_js__rspack_import_0 = __webpack_require__("./src/core/codex/contract.js");
         var node_fs__rspack_import_1 = __webpack_require__("node:fs");
         var _codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+        var _remote_control_js__rspack_import_3 = __webpack_require__("./src/core/codex/remote-control.js");
+        var _thread_id_js__rspack_import_4 = __webpack_require__("./src/core/codex/thread-id.js");
         const ID = /^[A-Za-z0-9_.:-]{1,128}$/;
         const BUDGET = 4 * 1024 * 1024;
         function conversationId(value, name = 'threadId') {
+            if (name === 'threadId') return (0, _thread_id_js__rspack_import_4.SX)(value);
             if (typeof value !== 'string' || !ID.test(value)) throw new RangeError(`${name} must be 1-128 identifier characters`);
             return value;
         }
@@ -23729,7 +23843,8 @@ var __webpack_modules__ = {
                 if (expected !== undefined && (typeof cwd !== 'string' || (0, node_fs__rspack_import_1.realpathSync)(cwd) !== expected)) throw new Error('Codex thread cwd does not match expectedCwd');
             } catch (error) {
                 await close();
-                throw error;
+                if (error instanceof _remote_control_js__rspack_import_3.Rg) throw error;
+                throw (0, _remote_control_js__rspack_import_3.R3)(error, threadId, env);
             }
             async function wait({ turnId, messageId, afterMessageId, timeoutMs = 120000, signal: waitSignal, maxOutputBytes = 1048576 }) {
                 conversationId(turnId, 'turnId');
@@ -24080,6 +24195,264 @@ var __webpack_modules__ = {
             j: ()=>openCodexConversation
         });
     },
+    "./src/core/codex/remote-control.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        var node_fs__rspack_import_0 = __webpack_require__("node:fs");
+        var node_os__rspack_import_1 = __webpack_require__("node:os");
+        var node_path__rspack_import_2 = __webpack_require__("node:path");
+        var _thread_id_js__rspack_import_3 = __webpack_require__("./src/core/codex/thread-id.js");
+        const REMOTE_SUMMARY_KEY = /^remote-thread-summaries-v3:(.+)$/;
+        class RemoteThreadNotLoadedError1 extends Error {
+            constructor(threadId, hostId = null, hostName = null){
+                const hostLabel = hostName ? `${JSON.stringify(hostName)} (${JSON.stringify(hostId)})` : hostId ? JSON.stringify(hostId) : null;
+                const owner = hostLabel ? `owned by remote-control host ${hostLabel}` : 'owned by a remote-control host (hostId unknown; check ~/.codex/.codex-global-state.json)';
+                const hint = hostId ? `Read this thread via host ${JSON.stringify(hostId)}'s app-server` + (hostName ? ` (${hostName})` : '') + '. SSH remoting is not implemented in this adapter.' : "Read this thread via the owning host's app-server. SSH remoting is not implemented in this adapter.";
+                super(`Codex thread ${JSON.stringify(threadId)} is not loaded on the local app-server; ${owner}. ${hint}`);
+                this.name = 'RemoteThreadNotLoadedError';
+                this.code = 'REMOTE_THREAD_NOT_LOADED';
+                this.delivery = 'rejected';
+                this.reason = 'remote-thread-not-loaded';
+                this.threadId = threadId;
+                this.hostId = hostId;
+                this.hostName = hostName;
+                this.hint = hint;
+            }
+        }
+        function codexGlobalStatePath(env = process.env) {
+            const home = env.CODEX_HOME || (0, node_path__rspack_import_2.join)((0, node_os__rspack_import_1.homedir)(), '.codex');
+            return (0, node_path__rspack_import_2.join)(home, '.codex-global-state.json');
+        }
+        function loadCodexGlobalState(env = process.env) {
+            let raw;
+            try {
+                raw = (0, node_fs__rspack_import_0.readFileSync)(codexGlobalStatePath(env), 'utf8');
+            } catch  {
+                return null;
+            }
+            try {
+                const data = JSON.parse(raw);
+                if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+                return data;
+            } catch  {
+                return null;
+            }
+        }
+        function codexStateEntries(data) {
+            const nested = data?.['electron-persisted-atom-state'];
+            return [
+                nested,
+                data
+            ].filter((value)=>value && typeof value === 'object' && !Array.isArray(value));
+        }
+        function findRemoteThreadHost(threadId, env = process.env) {
+            let bare;
+            try {
+                bare = (0, _thread_id_js__rspack_import_3.SX)(threadId);
+            } catch  {
+                bare = typeof threadId === 'string' && threadId.startsWith("local:") ? threadId.slice("local:".length) : threadId;
+            }
+            if (!bare) return null;
+            const data = loadCodexGlobalState(env);
+            if (!data) return null;
+            const hostNames = collectHostNames(data);
+            for (const [key, value] of codexStateEntries(data).flatMap(Object.entries)){
+                const match = REMOTE_SUMMARY_KEY.exec(key);
+                if (!match?.[1]) continue;
+                const hostId = match[1];
+                const hostName = hostNames.get(hostId) ?? extractHostName(value) ?? null;
+                for (const entry of extractThreadEntries(value)){
+                    const id = threadIdFromEntry(entry);
+                    if (!id) continue;
+                    const entryBare = id.startsWith("local:") ? id.slice("local:".length) : id;
+                    if (entryBare === bare) return {
+                        hostId,
+                        hostName
+                    };
+                }
+            }
+            return null;
+        }
+        function mapRemoteThreadError(error, threadId, env = process.env) {
+            const message = errorMessage(error);
+            if (!/thread not loaded|not loaded|no rollout found|thread not found|invalid thread id/i.test(message)) {
+                return error instanceof Error ? error : new Error(message || String(error));
+            }
+            const remote = findRemoteThreadHost(threadId, env);
+            if (remote) {
+                return new RemoteThreadNotLoadedError1(threadId, remote.hostId, remote.hostName);
+            }
+            if (/thread not loaded|not loaded/i.test(message)) {
+                return new RemoteThreadNotLoadedError1(threadId, null, null);
+            }
+            return error instanceof Error ? error : new Error(message || String(error));
+        }
+        function collectHostNames(data) {
+            const names = new Map();
+            for (const [key, value] of codexStateEntries(data).flatMap(Object.entries)){
+                if (!/remote-host|hosts|host-meta|host_directory|environments/i.test(key)) continue;
+                if (!value || typeof value !== 'object') continue;
+                if (Array.isArray(value)) {
+                    for (const entry of value){
+                        const pair = hostNameFromEntry(entry);
+                        if (pair && !names.has(pair.hostId)) names.set(pair.hostId, pair.hostName);
+                    }
+                    continue;
+                }
+                for (const [hostId, entry] of Object.entries(value)){
+                    const fromEntry = hostNameFromEntry(entry);
+                    if (fromEntry) {
+                        if (!names.has(fromEntry.hostId)) names.set(fromEntry.hostId, fromEntry.hostName);
+                        continue;
+                    }
+                    const label = stringField(entry, [
+                        'name',
+                        'hostName',
+                        'displayName',
+                        'envName',
+                        'label',
+                        'title'
+                    ]);
+                    if (label && !names.has(hostId)) names.set(hostId, label);
+                }
+            }
+            return names;
+        }
+        function hostNameFromEntry(entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+            const hostId = stringField(entry, [
+                'hostId',
+                'id',
+                'host_id',
+                'uuid'
+            ]);
+            const hostName = stringField(entry, [
+                'name',
+                'hostName',
+                'displayName',
+                'envName',
+                'label',
+                'title'
+            ]);
+            if (!hostId || !hostName) return null;
+            return {
+                hostId,
+                hostName
+            };
+        }
+        function extractHostName(value) {
+            if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+            return stringField(value, [
+                'hostName',
+                'displayName',
+                'name',
+                'envName',
+                'label',
+                'title',
+                'friendlyName'
+            ]);
+        }
+        function extractThreadEntries(value) {
+            if (Array.isArray(value)) return value;
+            if (!value || typeof value !== 'object') return [];
+            const record = value;
+            for (const key of [
+                'threads',
+                'summaries',
+                'items',
+                'data',
+                'conversations'
+            ]){
+                if (Array.isArray(record[key])) return record[key];
+            }
+            const entries = [];
+            for (const [key, entry] of Object.entries(record)){
+                if ([
+                    'pinnedIds',
+                    'pinned',
+                    'pinnedThreadIds',
+                    'hostName',
+                    'displayName',
+                    'name',
+                    'envName',
+                    'label',
+                    'title',
+                    'friendlyName',
+                    'hostId',
+                    'version'
+                ].includes(key)) continue;
+                if (typeof entry === 'string') continue;
+                if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+                    const id = stringField(entry, [
+                        'id',
+                        'threadId',
+                        'thread_id',
+                        'conversationId'
+                    ]);
+                    entries.push(id ? entry : {
+                        ...entry,
+                        id: key
+                    });
+                }
+            }
+            return entries;
+        }
+        function threadIdFromEntry(entry) {
+            if (typeof entry === 'string' && entry) return entry;
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+            return stringField(entry, [
+                'id',
+                'threadId',
+                'thread_id',
+                'conversationId'
+            ]);
+        }
+        function stringField(row, keys) {
+            if (!row || typeof row !== 'object' || Array.isArray(row)) return null;
+            for (const key of keys){
+                const value = row[key];
+                if (typeof value === 'string' && value.trim()) return value.trim();
+            }
+            return null;
+        }
+        function errorMessage(error) {
+            if (!error) return '';
+            if (typeof error === 'string') return error;
+            if (error instanceof Error) return error.message;
+            if (typeof error === 'object' && error && 'message' in error) return String(error.message);
+            if (typeof error === 'object' && error && 'rpc' in error) {
+                const rpc = error.rpc;
+                if (rpc && typeof rpc.message === 'string') return rpc.message;
+            }
+            return String(error);
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            R3: ()=>mapRemoteThreadError,
+            Rg: ()=>RemoteThreadNotLoadedError1
+        });
+    },
+    "./src/core/codex/thread-id.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        const LOCAL_THREAD_ID_PREFIX = 'local:';
+        const TEMP_THREAD_ID_PREFIX = 'local:client-new-thread:';
+        const ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+        function isTemporaryDesktopThreadId(threadId) {
+            return typeof threadId === 'string' && (threadId.startsWith(TEMP_THREAD_ID_PREFIX) || threadId.startsWith('client-new-thread:'));
+        }
+        function normalizeCodexThreadId1(threadId) {
+            if (typeof threadId !== 'string' || !threadId) {
+                throw new RangeError('Invalid threadId');
+            }
+            if (isTemporaryDesktopThreadId(threadId)) {
+                throw new RangeError('Temporary Desktop thread id ' + JSON.stringify(threadId) + ' has no app-server mapping; wait for the real conversation id');
+            }
+            const bare = threadId.startsWith(LOCAL_THREAD_ID_PREFIX) ? threadId.slice(LOCAL_THREAD_ID_PREFIX.length) : threadId;
+            if (!bare || !ID_PATTERN.test(bare)) {
+                throw new RangeError('Invalid threadId');
+            }
+            return bare;
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            SX: ()=>normalizeCodexThreadId1
+        });
+    },
     "./src/core/desktop-shim.js" (__unused_rspack___webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
         var node_child_process__rspack_import_0 = __webpack_require__("node:child_process");
         var node_fs__rspack_import_1 = __webpack_require__("node:fs");
@@ -27537,7 +27910,7 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
     },
     "./package.json" (module) {
         module.exports = {
-            "rE": "0.10.2"
+            "rE": "0.11.0"
         };
     }
 };

package/dist/skills/chatgpt-desktop/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: chatgpt-desktop
+description: Use the gbot ChatGPT Desktop MCP tools to discover hosts and threads, page/search/read conversations, and send or wait for replies on the user's Mac. Use for local Desktop CDP automation and remote-control thread routing; do not use for ordinary Grok Bot messaging.
+---
+# ChatGPT Desktop through gbot
+
+Use the `chatgpt_desktop_*` MCP tools on the user's Mac. The CLI is a secondary
+surface. CDP listens on `127.0.0.1` only; these tools do not transport CDP to
+another machine.
+
+## Find the right conversation
+
+1. Call `chatgpt_desktop_status`. `reachable: false` or `exitCode: 1` means
+   CDP is down: open/send/wait cannot work. `appServerFallback.reachable` is a
+   separate list/search/read probe. Do not retry a send because CDP disappeared.
+2. Call `chatgpt_desktop_list_hosts` for dynamic host IDs, labels, and
+   `modelProvider` values. `local` is this Mac. A remote-control host ID looks
+   like `remote-control:env_e_...`; its `hostName` may be `null`. Do not infer a
+   host name from a project label. Managed SSH hosts may have no threads.
+3. Use `chatgpt_desktop_list_threads` with `host`, `modelProvider`, or `project`
+   as needed. Pass `nextCursor` back as `cursor` with the same filters until it
+   is `null`. The cursor refers to a sorted merged inventory; pages normally
+   fill `limit` and can stop earlier at the MCP document cap. If the inventory
+   changed after a cursor expired, restart without one. Project labels and IDs
+   come from Desktop project assignments and workspace roots; `projectRootPath`
+   is the resolved root when available.
+   `chatgpt_desktop_search_threads` also accepts `cursor`; keep its query and
+   filters unchanged. Search matches the full title even when the display row
+   has a 200-character `title` and `titleTruncated: true`.
+4. Read with `chatgpt_desktop_read_thread`. `full: false` gets the recent tail;
+   `full: true` pages chronologically from the start. Pass `nextCursor` back
+   as `cursor` with the same thread ID and `full` value until `complete: true`.
+   The byte budget can stop before `limit`. An oversized turn is returned as
+   ordered fragments with one stable `turnKey`; use `continuation.field`,
+   `offsetChars`, and `totalChars` to reassemble `text`, `userText`, and
+   `assistantText`. `textTruncated: true` signals a fragment, not missing text.
+   Check `complete` and `warnings` before treating a page as full history.
+
+Durable local IDs are `local:<conversationId>` (a bare conversation ID also
+works). `local:client-new-thread:*` is temporary and works only while that
+conversation remains selected. `REMOTE_THREAD_NOT_LOADED` includes the
+owning `hostId`: read or send through gbot running on that host's own Desktop
+or app-server. The local Mac cannot fetch that remote history through CDP.
+
+## Open, send, and wait
+
+- `chatgpt_desktop_open_thread` navigates to a durable conversation even if it
+  is absent from the sidebar. An archived route returns `archived: true`; the
+  thread remains readable through `chatgpt_desktop_read_thread`.
+- `chatgpt_desktop_send` with `threadId` sends to that conversation. Omit
+  `threadId` and `project` to start outside a project. Omit `threadId` and set
+  `project` to start inside that project. The tool verifies the empty new-chat
+  view and its project selection before typing. Send once. A new-thread receipt may
+  include `temporaryThreadId` and resolves `threadId` to the durable
+  `local:<conversationId>` before returning. Keep both until the durable ID is
+  confirmed; use the durable ID for later work.
+- Then call `chatgpt_desktop_wait_reply` with the returned `threadId` (or the
+  selected temporary ID). It returns the reply and durable `conversationId`.
+  A timeout is an observation, not permission to resend.
+
+`ARCHIVED_THREAD` means send was rejected before submission. Read remains
+available. Pass `unarchive: true` with an existing `threadId` on send only if
+the user wants the archive state changed; this explicitly calls app-server
+`thread/unarchive` and retries once. Never unarchive merely to read or open.
+
+`COMPOSER_HAS_DRAFT` means the user's draft would be disturbed; leave it for
+the operator. `PROJECT_UNAVAILABLE` means Desktop disabled a project's new-chat
+action, often because its configured workspace root no longer exists; correct
+the project root in Desktop before retrying. `NEW_CHAT_NAVIGATION_FAILED` means
+the button did not open the requested empty view within three seconds; inspect
+Desktop before retrying. `CDP_UNREACHABLE` requires restoring the local Desktop CDP
+endpoint. App-server failures, including oversized frames, appear as errors or
+read `warnings` with `complete: false`; inspect the partial result and source
+status before continuing. A send with unknown delivery must not be repeated
+without checking the selected thread and reply state.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "CLI and Agent Bundle plugin for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "bin": {