tide-commander 1.148.0 → 1.149.0

package/dist/src/packages/server/grok/json-event-parser.js

@@ -0,0 +1,138 @@
+/**
+ * Grok headless streaming-json event parser.
+ * Maps NDJSON events from `grok -p … --output-format streaming-json` to StandardEvent.
+ *
+ * Documented event types: text, thought, end, error.
+ * Also handles max_turns_reached / auto_compact_* defensively.
+ *
+ * Grok emits one tiny token per NDJSON line. The client only merges streaming
+ * chunks when they share a `uuid`, so we mint a stable stream id per block
+ * (text / thinking) for the turn and finalize with isStreaming=false on end.
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('GrokParser');
+export class GrokJsonEventParser {
+    lastTextContent = '';
+    lastThinkingContent = '';
+    textEventEmittedInTurn = false;
+    /** Stable uuid so token-sized deltas merge into one terminal row. */
+    textStreamUuid;
+    thinkingStreamUuid;
+    parseEvent(rawEvent) {
+        const event = rawEvent;
+        if (!event || typeof event !== 'object' || !event.type) {
+            return [];
+        }
+        log.log(`parseEvent: type=${event.type}, sessionId=${event.sessionId || 'none'}`);
+        switch (event.type) {
+            case 'text':
+                return this.parseText(event);
+            case 'thought':
+                return this.parseThought(event);
+            case 'end':
+                return this.parseEnd(event);
+            case 'error':
+                return this.parseError(event);
+            case 'max_turns_reached':
+                return [{
+                        type: 'error',
+                        errorMessage: event.message || 'Max turns reached',
+                        sessionId: event.sessionId,
+                    }];
+            default:
+                // Unknown / telemetry events — ignore for UI, but keep the stream alive
+                log.log(`parseEvent: unknown event type '${event.type}' - skipping`);
+                return [];
+        }
+    }
+    ensureTextStreamUuid() {
+        if (!this.textStreamUuid) {
+            this.textStreamUuid = `grok-text-${randomUUID()}`;
+        }
+        return this.textStreamUuid;
+    }
+    ensureThinkingStreamUuid() {
+        if (!this.thinkingStreamUuid) {
+            this.thinkingStreamUuid = `grok-thinking-${randomUUID()}`;
+        }
+        return this.thinkingStreamUuid;
+    }
+    parseText(event) {
+        const chunk = event.data ?? event.text;
+        if (!chunk)
+            return [];
+        this.lastTextContent += chunk;
+        this.textEventEmittedInTurn = true;
+        return [{
+                type: 'text',
+                text: chunk,
+                isStreaming: true,
+                uuid: this.ensureTextStreamUuid(),
+                sessionId: event.sessionId,
+            }];
+    }
+    parseThought(event) {
+        const chunk = event.data ?? event.text;
+        if (!chunk)
+            return [];
+        this.lastThinkingContent += chunk;
+        return [{
+                type: 'thinking',
+                text: chunk,
+                isStreaming: true,
+                uuid: this.ensureThinkingStreamUuid(),
+                sessionId: event.sessionId,
+            }];
+    }
+    parseEnd(event) {
+        const events = [];
+        // Finalize open streams so the client stops treating the row as "live"
+        // and stops re-mounting/blinking. Final payload replaces the merged row
+        // (same uuid, isStreaming=false) with the full accumulated text.
+        if (this.thinkingStreamUuid && this.lastThinkingContent) {
+            events.push({
+                type: 'thinking',
+                text: this.lastThinkingContent,
+                isStreaming: false,
+                uuid: this.thinkingStreamUuid,
+                sessionId: event.sessionId,
+            });
+        }
+        if (this.textStreamUuid && this.lastTextContent) {
+            events.push({
+                type: 'text',
+                text: this.lastTextContent,
+                isStreaming: false,
+                uuid: this.textStreamUuid,
+                sessionId: event.sessionId,
+            });
+        }
+        const stepComplete = {
+            type: 'step_complete',
+            sessionId: event.sessionId,
+        };
+        if (this.lastTextContent) {
+            stepComplete.resultText = this.lastTextContent;
+        }
+        else if (this.lastThinkingContent && !this.textEventEmittedInTurn) {
+            // Thinking-only turn — surface a marker so the terminal isn't blank
+            stepComplete.resultText = `(Empty response: thinking only, stopReason=${event.stopReason || 'EndTurn'})`;
+        }
+        events.push(stepComplete);
+        // Reset per-turn accumulators / stream ids
+        this.lastTextContent = '';
+        this.lastThinkingContent = '';
+        this.textEventEmittedInTurn = false;
+        this.textStreamUuid = undefined;
+        this.thinkingStreamUuid = undefined;
+        return events;
+    }
+    parseError(event) {
+        return [{
+                type: 'error',
+                errorMessage: event.message || event.data || 'Grok CLI error',
+                sessionId: event.sessionId,
+            }];
+    }
+}

package/dist/src/packages/server/grok/session-watcher.js

@@ -0,0 +1,460 @@
+/**
+ * Grok session side-channel watcher.
+ *
+ * Headless `streaming-json` only emits thought/text/end on stdout. Tool use is
+ * recorded under ~/.grok/sessions/<encoded-cwd>/<sessionId>/. This watcher
+ * tails those files and emits StandardEvents so Tide can show tool cards live.
+ *
+ * Sources:
+ * - events.jsonl  → early tool_started/tool_completed (name only, fast)
+ * - chat_history.jsonl → tool_calls with args + tool_result with full output
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('GrokSessionWatcher');
+const MAX_TOOL_OUTPUT_CHARS = 50_000;
+const DISCOVER_INTERVAL_MS = 250;
+const TAIL_INTERVAL_MS = 200;
+/** Accept sessions modified up to this long before process start (slow disk / clock skew). */
+const DISCOVER_GRACE_MS = 5_000;
+/**
+ * Read context usage from a Grok session's signals.json.
+ * Streaming-json only emits thought/text/end — no token counts — so this file
+ * is the authoritative live source for the Tide context bar.
+ */
+export function readGrokSignalsUsage(sessionDir) {
+    const signalsPath = path.join(sessionDir, 'signals.json');
+    if (!fs.existsSync(signalsPath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(signalsPath, 'utf8'));
+        const used = Number(raw.contextTokensUsed);
+        const limit = Number(raw.contextWindowTokens);
+        if (!Number.isFinite(used) || !Number.isFinite(limit) || limit <= 0)
+            return null;
+        const usagePct = Number(raw.contextWindowUsage);
+        return {
+            contextTokensUsed: Math.max(0, Math.round(used)),
+            contextWindowTokens: Math.max(1, Math.round(limit)),
+            contextWindowUsage: Number.isFinite(usagePct) ? usagePct : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Grok stores sessions under encodeURIComponent(absolute cwd). */
+export function encodeGrokProjectKey(cwd) {
+    return encodeURIComponent(path.resolve(cwd));
+}
+export function getGrokSessionsRoot(cwd) {
+    return path.join(os.homedir(), '.grok', 'sessions', encodeGrokProjectKey(cwd));
+}
+export function getGrokSessionDir(cwd, sessionId) {
+    return path.join(getGrokSessionsRoot(cwd), sessionId);
+}
+const TOOL_NAME_MAP = {
+    list_dir: 'ListFiles',
+    read_file: 'Read',
+    search_replace: 'Edit',
+    write: 'Write',
+    run_terminal_cmd: 'Bash',
+    run_terminal_command: 'Bash',
+    grep: 'Grep',
+    web_search: 'WebSearch',
+    web_fetch: 'WebFetch',
+    open_page: 'WebFetch',
+    open_page_with_find: 'WebFetch',
+    spawn_subagent: 'Task',
+    todo_write: 'TodoWrite',
+    image_gen: 'ImageGen',
+    image_edit: 'ImageEdit',
+};
+export function normalizeGrokToolName(raw) {
+    if (!raw)
+        return 'unknown';
+    return TOOL_NAME_MAP[raw.toLowerCase()] || raw;
+}
+function parseToolInput(args) {
+    if (!args)
+        return {};
+    if (typeof args === 'object' && args !== null && !Array.isArray(args)) {
+        return args;
+    }
+    if (typeof args === 'string') {
+        try {
+            const parsed = JSON.parse(args);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            return { raw: args };
+        }
+        catch {
+            return { raw: args };
+        }
+    }
+    return {};
+}
+function truncateOutput(text) {
+    if (text.length <= MAX_TOOL_OUTPUT_CHARS)
+        return text;
+    return text.slice(0, MAX_TOOL_OUTPUT_CHARS) + `\n… [truncated ${text.length - MAX_TOOL_OUTPUT_CHARS} chars]`;
+}
+/**
+ * Append-only JSONL tailer. Starts at EOF so prior-turn tools are not re-broadcast.
+ */
+export class JsonlTailer {
+    position = 0;
+    buffer = '';
+    initialized = false;
+    filePath;
+    onLine;
+    constructor(filePath, onLine) {
+        this.filePath = filePath;
+        this.onLine = onLine;
+    }
+    initAtEof() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                this.position = fs.statSync(this.filePath).size;
+            }
+            else {
+                this.position = 0;
+            }
+        }
+        catch {
+            this.position = 0;
+        }
+        this.buffer = '';
+        this.initialized = true;
+    }
+    poll() {
+        if (!this.initialized)
+            this.initAtEof();
+        try {
+            if (!fs.existsSync(this.filePath))
+                return;
+            const stat = fs.statSync(this.filePath);
+            if (stat.size < this.position) {
+                this.position = 0;
+                this.buffer = '';
+            }
+            if (stat.size === this.position)
+                return;
+            const fd = fs.openSync(this.filePath, 'r');
+            try {
+                const toRead = stat.size - this.position;
+                const buf = Buffer.alloc(toRead);
+                fs.readSync(fd, buf, 0, toRead, this.position);
+                this.position = stat.size;
+                this.buffer += buf.toString('utf8');
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    this.onLine(JSON.parse(trimmed));
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+        catch (err) {
+            log.log(`tail poll error for ${this.filePath}: ${String(err)}`);
+        }
+    }
+}
+export function startGrokSessionWatcher(opts) {
+    const startedAt = opts.startedAt ?? Date.now();
+    let stopped = false;
+    let sessionId = opts.sessionId;
+    let sessionDirPath = null;
+    let chatTailer = null;
+    let eventsTailer = null;
+    let discoverTimer = null;
+    let tailTimer = null;
+    /** Dedupe key for last-emitted signals usage snapshot. */
+    let lastSignalsUsageKey = '';
+    const emittedToolStarts = new Set();
+    const emittedToolResults = new Set();
+    /** raw tool_name → queue of early synthetic ids (events.jsonl, no call id) */
+    const pendingEarlyByName = new Map();
+    const earlyToReal = new Map();
+    const realToEarly = new Map();
+    const emit = (event) => {
+        if (stopped)
+            return;
+        opts.onEvent(event);
+    };
+    const pollSignalsUsage = () => {
+        if (!sessionDirPath)
+            return;
+        const usage = readGrokSignalsUsage(sessionDirPath);
+        if (!usage)
+            return;
+        const key = `${usage.contextTokensUsed}:${usage.contextWindowTokens}`;
+        if (key === lastSignalsUsageKey)
+            return;
+        lastSignalsUsageKey = key;
+        // Encode fill as input tokens so usage_snapshot handlers treat it as
+        // current context size (cache fields left 0).
+        emit({
+            type: 'usage_snapshot',
+            tokens: {
+                input: usage.contextTokensUsed,
+                output: 0,
+                cacheRead: 0,
+                cacheCreation: 0,
+            },
+            modelUsage: {
+                contextWindow: usage.contextWindowTokens,
+                inputTokens: usage.contextTokensUsed,
+                outputTokens: 0,
+            },
+            sessionId: sessionId,
+        });
+        log.log(`📊 Grok signals usage for ${opts.agentId.slice(0, 8)}: ${usage.contextTokensUsed}/${usage.contextWindowTokens}`
+            + (usage.contextWindowUsage != null ? ` (${usage.contextWindowUsage}%)` : ''));
+    };
+    const handleEventsLine = (raw) => {
+        const line = raw;
+        if (!line || typeof line !== 'object' || !line.type)
+            return;
+        if (line.type === 'turn_started' && typeof line.session_id === 'string') {
+            if (sessionId !== line.session_id) {
+                sessionId = line.session_id;
+                opts.onSessionId?.(sessionId);
+            }
+            return;
+        }
+        if (line.type === 'tool_started' && line.tool_name) {
+            const rawName = line.tool_name;
+            const toolName = normalizeGrokToolName(rawName);
+            const synthId = `grok-early-${rawName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const queue = pendingEarlyByName.get(rawName) || [];
+            queue.push(synthId);
+            pendingEarlyByName.set(rawName, queue);
+            emittedToolStarts.add(synthId);
+            emit({
+                type: 'tool_start',
+                toolName,
+                toolInput: {},
+                toolUseId: synthId,
+                uuid: synthId,
+            });
+            return;
+        }
+        if (line.type === 'tool_completed' && line.tool_name) {
+            const rawName = line.tool_name;
+            const queue = pendingEarlyByName.get(rawName);
+            if (!queue || queue.length === 0)
+                return;
+            const synthId = queue.shift();
+            if (queue.length === 0)
+                pendingEarlyByName.delete(rawName);
+            else
+                pendingEarlyByName.set(rawName, queue);
+            // If chat_history already completed the real call, skip empty early result.
+            if (emittedToolResults.has(synthId))
+                return;
+            // If this early was upgraded to a real call id that already has a result, skip.
+            const realId = earlyToReal.get(synthId);
+            if (realId && emittedToolResults.has(realId)) {
+                emittedToolResults.add(synthId);
+                return;
+            }
+            emittedToolResults.add(synthId);
+            emit({
+                type: 'tool_result',
+                toolName: normalizeGrokToolName(rawName),
+                toolUseId: synthId,
+                uuid: synthId,
+                toolOutput: line.outcome === 'success' ? '(ok)' : `(${line.outcome || 'done'})`,
+            });
+            // Tools change context fill — re-read signals after completions.
+            pollSignalsUsage();
+            return;
+        }
+        // End of model turn is a good moment to refresh context stats.
+        if (line.type === 'turn_ended') {
+            pollSignalsUsage();
+        }
+    };
+    const handleChatLine = (raw) => {
+        const line = raw;
+        if (!line || typeof line !== 'object')
+            return;
+        if (line.type === 'assistant' && Array.isArray(line.tool_calls)) {
+            for (const call of line.tool_calls) {
+                const callId = call.id || `anon-${call.name}-${Date.now()}`;
+                if (emittedToolStarts.has(callId))
+                    continue;
+                const rawName = call.name || 'unknown';
+                const toolName = normalizeGrokToolName(rawName);
+                const toolInput = parseToolInput(call.arguments);
+                // Link to a pending early card for this tool name (if any)
+                const earlyQueue = pendingEarlyByName.get(rawName);
+                if (earlyQueue && earlyQueue.length > 0) {
+                    const earlyId = earlyQueue.shift();
+                    if (earlyQueue.length === 0)
+                        pendingEarlyByName.delete(rawName);
+                    earlyToReal.set(earlyId, callId);
+                    realToEarly.set(callId, earlyId);
+                }
+                emittedToolStarts.add(callId);
+                // Prefer upgrading the early card (same uuid) with full args so the UI
+                // does not keep an empty "Using tool: Read" plus a second full row.
+                // tool_result dual-emits to earlyId + callId for pairing.
+                const earlyId = realToEarly.get(callId);
+                if (earlyId) {
+                    emit({
+                        type: 'tool_start',
+                        toolName,
+                        toolInput,
+                        toolUseId: earlyId,
+                        uuid: earlyId,
+                    });
+                }
+                else {
+                    emit({
+                        type: 'tool_start',
+                        toolName,
+                        toolInput,
+                        toolUseId: callId,
+                        uuid: callId,
+                    });
+                }
+            }
+            return;
+        }
+        if (line.type === 'tool_result' && line.tool_call_id) {
+            const callId = line.tool_call_id;
+            if (emittedToolResults.has(callId))
+                return;
+            emittedToolResults.add(callId);
+            const content = typeof line.content === 'string'
+                ? line.content
+                : line.content != null
+                    ? JSON.stringify(line.content)
+                    : '';
+            const out = truncateOutput(content);
+            emit({
+                type: 'tool_result',
+                toolUseId: callId,
+                uuid: callId,
+                toolOutput: out,
+            });
+            const earlyId = realToEarly.get(callId);
+            if (earlyId && !emittedToolResults.has(earlyId)) {
+                emittedToolResults.add(earlyId);
+                emit({
+                    type: 'tool_result',
+                    toolUseId: earlyId,
+                    uuid: earlyId,
+                    toolOutput: out,
+                });
+            }
+        }
+    };
+    const attachToSession = (id) => {
+        sessionId = id;
+        opts.onSessionId?.(id);
+        const sessionDir = getGrokSessionDir(opts.workingDir, id);
+        sessionDirPath = sessionDir;
+        const chatPath = path.join(sessionDir, 'chat_history.jsonl');
+        const eventsPath = path.join(sessionDir, 'events.jsonl');
+        log.log(`📎 Watching Grok session ${id.slice(0, 8)}… for agent ${opts.agentId.slice(0, 8)}`);
+        chatTailer = new JsonlTailer(chatPath, handleChatLine);
+        eventsTailer = new JsonlTailer(eventsPath, handleEventsLine);
+        chatTailer.initAtEof();
+        eventsTailer.initAtEof();
+        // Seed context bar from existing signals (resume / mid-session attach).
+        lastSignalsUsageKey = '';
+        pollSignalsUsage();
+        if (discoverTimer) {
+            clearInterval(discoverTimer);
+            discoverTimer = null;
+        }
+        if (!tailTimer) {
+            tailTimer = setInterval(() => {
+                if (stopped)
+                    return;
+                eventsTailer?.poll();
+                chatTailer?.poll();
+                // signals.json is rewritten in place (not append-only) — poll each tick.
+                pollSignalsUsage();
+            }, TAIL_INTERVAL_MS);
+        }
+    };
+    const tryDiscover = () => {
+        const root = getGrokSessionsRoot(opts.workingDir);
+        if (!fs.existsSync(root))
+            return false;
+        let newest = null;
+        try {
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const dir = path.join(root, entry.name);
+                try {
+                    const st = fs.statSync(dir);
+                    if (st.mtimeMs < startedAt - DISCOVER_GRACE_MS)
+                        continue;
+                    if (!newest || st.mtimeMs > newest.mtime) {
+                        newest = { id: entry.name, mtime: st.mtimeMs };
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        if (!newest)
+            return false;
+        const sessionDir = getGrokSessionDir(opts.workingDir, newest.id);
+        const hasChat = fs.existsSync(path.join(sessionDir, 'chat_history.jsonl'));
+        const hasEvents = fs.existsSync(path.join(sessionDir, 'events.jsonl'));
+        if (!hasChat && !hasEvents)
+            return false;
+        attachToSession(newest.id);
+        return true;
+    };
+    if (sessionId) {
+        attachToSession(sessionId);
+    }
+    else if (!tryDiscover()) {
+        discoverTimer = setInterval(() => {
+            if (stopped)
+                return;
+            tryDiscover();
+        }, DISCOVER_INTERVAL_MS);
+    }
+    return {
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            if (discoverTimer)
+                clearInterval(discoverTimer);
+            if (tailTimer)
+                clearInterval(tailTimer);
+            discoverTimer = null;
+            tailTimer = null;
+            chatTailer = null;
+            eventsTailer = null;
+            log.log(`🛑 Stopped Grok session watcher for agent ${opts.agentId.slice(0, 8)}`);
+        },
+    };
+}

package/dist/src/packages/server/routes/agents.js

@@ -503,14 +503,17 @@ router.post('/bulk/change-model', async (req, res) => {
         else if (provider === 'opencode') {
             sanitized = agentService.sanitizeOpencodeModel(model);
         }
+        else if (provider === 'grok') {
+            sanitized = agentService.sanitizeGrokModel(model);
+        }
         if (!sanitized) {
             res.status(400).json({ error: `Invalid model "${model}" for provider "${provider}"` });
             return;
         }
-        // Effort is Claude-only. `null` means "clear back to default"; undefined means "leave unchanged".
+        // Effort is Claude/Grok. `null` means "clear back to default"; undefined means "leave unchanged".
         const VALID_EFFORTS = new Set(['low', 'medium', 'high', 'xHigh', 'max']);
         let effortUpdate = { set: false };
-        if (effort !== undefined && provider === 'claude') {
+        if (effort !== undefined && (provider === 'claude' || provider === 'grok')) {
             if (effort === null) {
                 effortUpdate = { set: true, value: undefined };
             }
@@ -547,6 +550,8 @@ router.post('/bulk/change-model', async (req, res) => {
                     modelUpdates.codexModel = sanitized;
                 else if (provider === 'opencode')
                     modelUpdates.opencodeModel = sanitized;
+                else if (provider === 'grok')
+                    modelUpdates.grokModel = sanitized;
                 if (effortUpdate.set)
                     modelUpdates.effort = effortUpdate.value;
                 agentService.updateAgent(agentId, modelUpdates);

package/dist/src/packages/server/runtime/grok-runtime-provider.js

@@ -0,0 +1,11 @@
+import { ClaudeRunner } from '../claude/runner.js';
+import { GrokBackend } from '../grok/backend.js';
+class GrokRuntimeProvider {
+    name = 'grok';
+    createRunner(callbacks) {
+        return new ClaudeRunner(callbacks, new GrokBackend());
+    }
+}
+export function createGrokRuntimeProvider() {
+    return new GrokRuntimeProvider();
+}

package/dist/src/packages/server/runtime/index.js

@@ -1,3 +1,4 @@
 export { createClaudeRuntimeProvider } from './claude-runtime-provider.js';
 export { createCodexRuntimeProvider } from './codex-runtime-provider.js';
 export { createOpencodeRuntimeProvider } from './opencode-runtime-provider.js';
+export { createGrokRuntimeProvider } from './grok-runtime-provider.js';