tide-commander 1.148.0 → 1.150.0

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

@@ -156,6 +156,15 @@ export class CodexJsonEventParser {
     enableFileDiffEnrichment;
     workingDirectory;
     gitRootCache = new Map();
+    /**
+     * Progressive agent_message text per item.id (for item.updated / delta streams).
+     * Current `codex exec --json` only emits agent_message on item.completed, but
+     * app-server / newer CLIs can stream via item.updated or agentMessage deltas.
+     */
+    streamedAgentTextByItemId = new Map();
+    openAgentTextUuids = new Set();
+    streamedThinkingByItemId = new Map();
+    openThinkingUuids = new Set();
     constructor(options = {}) {
         this.enableFileDiffEnrichment = options.enableFileDiffEnrichment === true;
         this.workingDirectory = options.workingDirectory || process.cwd();
@@ -190,6 +199,9 @@ export class CodexJsonEventParser {
         if (event.type === 'item.started') {
             return this.parseItemStarted(event.item);
         }
+        if (event.type === 'item.updated') {
+            return this.parseItemUpdated(event.item);
+        }
         if (event.type === 'item.completed') {
             // Capture agent message text for later use in step_complete
             if (event.item?.type === 'agent_message' && event.item?.text) {
@@ -197,6 +209,12 @@ export class CodexJsonEventParser {
             }
             return this.parseItemCompleted(event.item);
         }
+        // App-server style notification (when present on exec stream): streaming text delta.
+        if (event.type === 'item/agentMessage/delta' ||
+            event.type === 'item.agentMessage.delta' ||
+            event.type === 'agent_message_delta') {
+            return this.parseAgentMessageDelta(rawEvent);
+        }
         if (event.type === 'turn.completed') {
             return this.parseTurnCompleted(event.usage);
         }
@@ -228,12 +246,27 @@ export class CodexJsonEventParser {
             };
             return [];
         }
-        // agent_reasoning: Map to thinking event
+        // agent_reasoning: Map to thinking event (stable uuid when item id present)
         if (payloadType === 'agent_reasoning') {
             const text = asString(payload.text);
             if (!text)
                 return [];
-            return [{ type: 'thinking', text, isStreaming: false }];
+            const itemId = asString(payload.item_id) || asString(payload.id);
+            const uuid = itemId ? `codex-thinking-${itemId}` : undefined;
+            return [{ type: 'thinking', text, isStreaming: false, uuid }];
+        }
+        // Streaming agent message delta (app-server / experimental envelopes)
+        if (payloadType === 'agent_message_delta' ||
+            payloadType === 'agent_message/delta' ||
+            payloadType === 'output_text_delta') {
+            const delta = asString(payload.text) ||
+                asString(payload.delta);
+            if (!delta)
+                return [];
+            const itemId = asString(payload.item_id) ||
+                asString(payload.id) ||
+                'anon';
+            return this.appendAgentTextDelta(itemId, delta);
         }
         // turn_aborted: Silent. The interruption is already visible from the agent stopping.
         if (payloadType === 'turn_aborted') {
@@ -391,9 +424,109 @@ export class CodexJsonEventParser {
                 toolOutput,
             }];
     }
+    /** Stable uuid for a Codex agent_message item so streaming chunks merge. */
+    agentTextUuid(itemId) {
+        return `codex-text-${itemId}`;
+    }
+    appendAgentTextDelta(itemId, delta) {
+        if (!delta)
+            return [];
+        const prev = this.streamedAgentTextByItemId.get(itemId) || '';
+        const next = prev + delta;
+        this.streamedAgentTextByItemId.set(itemId, next);
+        this.lastAgentMessageText = next;
+        const uuid = this.agentTextUuid(itemId);
+        this.openAgentTextUuids.add(uuid);
+        return [{ type: 'text', text: delta, isStreaming: true, uuid }];
+    }
+    /**
+     * Progressive snapshot for agent_message / reasoning on item.updated.
+     * Emits only the new suffix when text grows (prefix match).
+     */
+    emitProgressiveItemText(kind, itemId, fullText, isFinal) {
+        if (!fullText)
+            return [];
+        const id = itemId || 'anon';
+        const map = kind === 'text' ? this.streamedAgentTextByItemId : this.streamedThinkingByItemId;
+        const openSet = kind === 'text' ? this.openAgentTextUuids : this.openThinkingUuids;
+        const uuid = kind === 'text' ? this.agentTextUuid(id) : `codex-thinking-${id}`;
+        const prev = map.get(id) || '';
+        if (kind === 'text')
+            this.lastAgentMessageText = fullText;
+        if (fullText === prev) {
+            if (isFinal && openSet.has(uuid)) {
+                openSet.delete(uuid);
+                map.delete(id);
+                return [{ type: kind === 'text' ? 'text' : 'thinking', text: fullText, isStreaming: false, uuid }];
+            }
+            return [];
+        }
+        map.set(id, fullText);
+        if (!isFinal && fullText.startsWith(prev)) {
+            const delta = fullText.slice(prev.length);
+            if (!delta)
+                return [];
+            openSet.add(uuid);
+            return [{ type: kind === 'text' ? 'text' : 'thinking', text: delta, isStreaming: true, uuid }];
+        }
+        openSet.delete(uuid);
+        if (isFinal)
+            map.delete(id);
+        return [{ type: kind === 'text' ? 'text' : 'thinking', text: fullText, isStreaming: false, uuid }];
+    }
+    parseItemUpdated(item) {
+        if (!item?.type)
+            return [];
+        // Progressive agent_message text (when CLI emits item.updated for messages).
+        if (item.type === 'agent_message' && item.text) {
+            const sanitized = sanitizeCodexMessageText(item.text);
+            if (!sanitized.text)
+                return [];
+            return this.emitProgressiveItemText('text', item.id, sanitized.text, false);
+        }
+        if (item.type === 'reasoning' && item.text) {
+            return this.emitProgressiveItemText('thinking', item.id, item.text, false);
+        }
+        // todo_list updates are already handled elsewhere as non-text progress;
+        // leave other item.updated types silent to avoid raw dumps.
+        if (item.type === 'todo_list') {
+            return [];
+        }
+        return [];
+    }
+    parseAgentMessageDelta(rawEvent) {
+        if (!isObject(rawEvent))
+            return [];
+        const item = isObject(rawEvent.item) ? rawEvent.item : undefined;
+        const params = isObject(rawEvent.params) ? rawEvent.params : undefined;
+        const delta = asString(rawEvent.delta) ||
+            asString(rawEvent.text) ||
+            asString(item?.text) ||
+            (params ? asString(params.delta) || asString(params.text) : undefined);
+        if (!delta)
+            return [];
+        const itemId = asString(item?.id) ||
+            asString(rawEvent.item_id) ||
+            asString(rawEvent.id) ||
+            (params ? asString(params.item_id) || asString(params.id) : undefined) ||
+            'anon';
+        return this.appendAgentTextDelta(itemId, delta);
+    }
     parseItemStarted(item) {
         if (!item?.type)
             return [];
+        // Some Codex builds open agent_message with empty text on item.started;
+        // pin the stream uuid so later updates merge into one row.
+        if (item.type === 'agent_message') {
+            if (item.id) {
+                const uuid = this.agentTextUuid(item.id);
+                this.openAgentTextUuids.add(uuid);
+                if (item.text) {
+                    return this.emitProgressiveItemText('text', item.id, item.text, false);
+                }
+            }
+            return [];
+        }
         if (item.type === 'web_search') {
             const toolName = 'web_search';
             if (item.id) {
@@ -446,7 +579,12 @@ export class CodexJsonEventParser {
             return [{ type: 'error', errorMessage }];
         }
         if (item.type === 'reasoning' && item.text) {
-            return [{ type: 'thinking', text: item.text, isStreaming: false }];
+            const uuid = item.id ? `codex-thinking-${item.id}` : undefined;
+            if (item.id) {
+                this.streamedThinkingByItemId.delete(item.id);
+                this.openThinkingUuids.delete(uuid);
+            }
+            return [{ type: 'thinking', text: item.text, isStreaming: false, uuid }];
         }
         // Handle agent_message regardless of whether `text` is present. An empty
         // agent_message (text:"" or missing) must be suppressed — NOT allowed to
@@ -467,7 +605,14 @@ export class CodexJsonEventParser {
             // Empty message → render nothing (no empty bubble, no raw debug line).
             if (!sanitized.text)
                 return [];
-            return [{ type: 'text', text: sanitized.text, isStreaming: false }];
+            const uuid = item.id ? `codex-text-${item.id}` : undefined;
+            if (item.id) {
+                this.streamedAgentTextByItemId.delete(item.id);
+                if (uuid)
+                    this.openAgentTextUuids.delete(uuid);
+            }
+            // isStreaming:false finalizes any prior streaming row with the same uuid.
+            return [{ type: 'text', text: sanitized.text, isStreaming: false, uuid }];
         }
         if (item.type === 'web_search') {
             const toolName = item.id ? (this.activeToolByItemId.get(item.id) ?? 'web_search') : 'web_search';

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

@@ -129,6 +129,7 @@ function toStoredAgents(agents) {
         codexModel: agent.codexModel,
         codexConfig: agent.codexConfig,
         opencodeModel: agent.opencodeModel,
+        grokModel: agent.grokModel,
         createdAt: agent.createdAt,
         lastActivity: agent.lastActivity,
         sessionId: agent.sessionId,

package/dist/src/packages/server/grok/backend.js

@@ -0,0 +1,235 @@
+/**
+ * Grok CLI Backend (headless mode)
+ *
+ * Spawns: grok -p … --output-format streaming-json [--yolo] [--resume id] …
+ * Large prompts go through --prompt-file (Grok does not read the prompt from stdin).
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { GrokJsonEventParser } from './json-event-parser.js';
+import { TIDE_COMMANDER_APPENDED_PROMPT } from '../prompts/tide-commander.js';
+import { getSystemPrompt, isEchoPromptEnabled } from '../services/system-prompt-service.js';
+import { consumeInstructionsDirty, isBareSlashCommand } from '../services/instruction-refresh.js';
+import { loadAreas } from '../data/index.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('GrokBackend');
+/** Prompt size above which we switch from -p to --prompt-file (argv safety). */
+const PROMPT_FILE_THRESHOLD = 4000;
+export function buildGrokPrompt(config) {
+    const userPrompt = config.prompt?.trim() || 'Continue the task.';
+    // Bare slash commands must reach the CLI verbatim.
+    if (isBareSlashCommand(userPrompt)) {
+        return userPrompt;
+    }
+    const echoedUserPrompt = isEchoPromptEnabled()
+        ? userPrompt + '\n\n---\n\n' + userPrompt
+        : userPrompt;
+    // On resume the instruction block is already in session history — only
+    // re-inject when an instruction source was dirtied mid-session.
+    const refreshInstructions = consumeInstructionsDirty(config.agentId);
+    if (config.sessionId && !refreshInstructions) {
+        return echoedUserPrompt;
+    }
+    const injectedSections = [];
+    const systemLevelPrompt = getSystemPrompt().trim();
+    if (systemLevelPrompt) {
+        injectedSections.push(`## System-Level Custom Prompt\n${systemLevelPrompt}`);
+    }
+    if (config.agentId) {
+        const areas = loadAreas();
+        const agentArea = areas.find(a => a.assignedAgentIds.includes(config.agentId));
+        const areaPrompt = agentArea?.prompt?.trim();
+        if (areaPrompt) {
+            injectedSections.push(`## Area-Level Prompt (${agentArea.name})\n${areaPrompt}`);
+        }
+    }
+    const customPrompt = config.customAgent?.definition?.prompt?.trim();
+    if (customPrompt) {
+        injectedSections.push(`## Agent Instructions\n${customPrompt}`);
+    }
+    const systemPrompt = config.systemPrompt?.trim();
+    if (systemPrompt) {
+        injectedSections.push(`## System Context\n${systemPrompt}`);
+    }
+    injectedSections.push(TIDE_COMMANDER_APPENDED_PROMPT);
+    return [
+        'Follow all instructions below for this task.',
+        ...injectedSections,
+        '## User Request',
+        echoedUserPrompt,
+    ].join('\n\n');
+}
+function shouldPassGrokModel(model) {
+    if (!model)
+        return false;
+    // Reject Claude/Codex short names that may leak across provider switches
+    if (model === 'sonnet' ||
+        model === 'opus' ||
+        model === 'haiku' ||
+        model === 'codex' ||
+        model.startsWith('claude-') ||
+        model.startsWith('gpt-')) {
+        return false;
+    }
+    return true;
+}
+export class GrokBackend {
+    name = 'grok';
+    parser = new GrokJsonEventParser();
+    /** Temp prompt files created for this process; cleaned after formatStdin (no-op) or next buildArgs. */
+    lastPromptFile;
+    buildArgs(config) {
+        // Clean previous prompt file if any (best-effort)
+        this.cleanupPromptFile();
+        const prompt = buildGrokPrompt(config);
+        const args = ['--output-format', 'streaming-json', '--no-auto-update'];
+        // Autonomous by default (matches OpenCode/Codex Tide defaults). Interactive
+        // mode still uses yolo for headless — Grok can't prompt through our UI yet.
+        if (config.permissionMode !== 'interactive') {
+            args.push('--yolo');
+        }
+        else {
+            // Interactive still needs unattended tool approval for headless; use
+            // always-approve so runs don't hang waiting for a TTY prompt.
+            args.push('--always-approve');
+        }
+        if (config.workingDir) {
+            args.push('--cwd', config.workingDir);
+        }
+        if (shouldPassGrokModel(config.model)) {
+            args.push('-m', config.model);
+        }
+        if (config.effort) {
+            // Map Tide effort labels to Grok reasoning-effort values
+            const effortMap = {
+                low: 'low',
+                medium: 'medium',
+                high: 'high',
+                xHigh: 'xhigh',
+                max: 'max',
+            };
+            const mapped = effortMap[config.effort] || config.effort.toLowerCase();
+            args.push('--reasoning-effort', mapped);
+        }
+        // Session resume / fork
+        if (config.sessionId) {
+            args.push('--resume', config.sessionId);
+            if (config.forkSession) {
+                args.push('--fork-session');
+            }
+        }
+        // Prompt delivery: -p for small prompts, --prompt-file for large ones
+        // (Grok does not read the prompt from stdin).
+        if (prompt.length > PROMPT_FILE_THRESHOLD) {
+            const promptFile = path.join(os.tmpdir(), `tide-grok-prompt-${config.agentId || 'anon'}-${Date.now()}.txt`);
+            fs.writeFileSync(promptFile, prompt, 'utf-8');
+            this.lastPromptFile = promptFile;
+            args.push('--prompt-file', promptFile);
+            log.log(`buildArgs: prompt via file (${prompt.length} chars) sessionId=${config.sessionId ? 'yes' : 'no'}`);
+        }
+        else {
+            args.push('-p', prompt);
+            log.log(`buildArgs: prompt via -p (${prompt.length} chars) sessionId=${config.sessionId ? 'yes' : 'no'}`);
+        }
+        return args;
+    }
+    parseEvent(rawEvent) {
+        const events = this.parser.parseEvent(rawEvent);
+        if (events.length === 0)
+            return null;
+        return events.length === 1 ? events[0] : events;
+    }
+    /** See CLIBackend.breakOpenStreams — tool-boundary stream split for Grok. */
+    breakOpenStreams() {
+        return this.parser.breakOpenStreams();
+    }
+    extractSessionId(rawEvent) {
+        const event = rawEvent;
+        if (event?.sessionId && typeof event.sessionId === 'string') {
+            return event.sessionId;
+        }
+        // end event also carries sessionId
+        if (event?.type === 'end' && typeof event.sessionId === 'string') {
+            return event.sessionId;
+        }
+        return null;
+    }
+    getExecutablePath() {
+        const envBinary = process.env.GROK_BINARY;
+        if (envBinary && fs.existsSync(envBinary)) {
+            return envBinary;
+        }
+        return this.detectInstallation() || 'grok';
+    }
+    detectInstallation() {
+        const homeDir = os.homedir();
+        const isWindows = process.platform === 'win32';
+        const possiblePaths = isWindows
+            ? [
+                path.join(homeDir, '.grok', 'bin', 'grok.exe'),
+                path.join(homeDir, 'AppData', 'Roaming', 'npm', 'grok.cmd'),
+            ]
+            : [
+                path.join(homeDir, '.grok', 'bin', 'grok'),
+                path.join(homeDir, '.local', 'bin', 'grok'),
+                '/usr/local/bin/grok',
+                '/usr/bin/grok',
+            ];
+        for (const p of possiblePaths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+        try {
+            const result = execSync('which grok', { encoding: 'utf-8', timeout: 5000 }).trim();
+            return result || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getExtraEnv() {
+        // Ensure ~/.grok/bin is on PATH if present (managed installs live there)
+        const grokBin = path.join(os.homedir(), '.grok', 'bin');
+        if (fs.existsSync(grokBin)) {
+            const sep = process.platform === 'win32' ? ';' : ':';
+            return { PATH: grokBin + sep + (process.env.PATH || '') };
+        }
+        return {};
+    }
+    /**
+     * Prompt is passed via -p / --prompt-file, not stdin.
+     */
+    requiresStdinInput() {
+        return false;
+    }
+    /**
+     * Mark as stdin-closed so follow-up messages queue and respawn with --resume
+     * (same delivery path as Codex/OpenCode).
+     */
+    shouldCloseStdinAfterPrompt() {
+        return true;
+    }
+    supportsSessionResume() {
+        return true;
+    }
+    formatStdinInput(_prompt) {
+        // Not used (requiresStdinInput=false). Clean up any leftover prompt file.
+        this.cleanupPromptFile();
+        return '';
+    }
+    cleanupPromptFile() {
+        if (!this.lastPromptFile)
+            return;
+        try {
+            if (fs.existsSync(this.lastPromptFile)) {
+                fs.unlinkSync(this.lastPromptFile);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        this.lastPromptFile = undefined;
+    }
+}

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

@@ -0,0 +1,4 @@
+export { GrokBackend, buildGrokPrompt } from './backend.js';
+export { GrokJsonEventParser } from './json-event-parser.js';
+export { startGrokSessionWatcher, encodeGrokProjectKey, getGrokSessionsRoot, getGrokSessionDir, normalizeGrokToolName, } from './session-watcher.js';
+export const GROK_PROVIDER_NAME = 'grok';

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

@@ -0,0 +1,153 @@
+/**
+ * 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,
+            }];
+    }
+    /**
+     * Finalize open text/thinking streams and mint new uuids for the next
+     * generation — WITHOUT step_complete (agent stays "working").
+     *
+     * Grok keeps one agentic turn across many tool rounds and does not emit
+     * `end` between them. Without this break, every intermediate status line
+     * concatenates into a single mashed bubble until the final end.
+     */
+    breakOpenStreams(sessionId) {
+        const events = [];
+        if (this.thinkingStreamUuid && this.lastThinkingContent) {
+            events.push({
+                type: 'thinking',
+                text: this.lastThinkingContent,
+                isStreaming: false,
+                uuid: this.thinkingStreamUuid,
+                sessionId,
+            });
+        }
+        if (this.textStreamUuid && this.lastTextContent) {
+            events.push({
+                type: 'text',
+                text: this.lastTextContent,
+                isStreaming: false,
+                uuid: this.textStreamUuid,
+                sessionId,
+            });
+        }
+        this.lastTextContent = '';
+        this.lastThinkingContent = '';
+        // Keep textEventEmittedInTurn so a later end/step_complete still knows
+        // we produced text this turn (avoids empty-thinking fallback).
+        this.textStreamUuid = undefined;
+        this.thinkingStreamUuid = undefined;
+        return events;
+    }
+    parseEnd(event) {
+        // Finalize open streams (same as a tool-boundary break) then step_complete.
+        const events = this.breakOpenStreams(event.sessionId);
+        // breakOpenStreams cleared accumulators — re-read is not possible. Capture
+        // resultText from the finalize events we just built.
+        const finalizedText = events.find((e) => e.type === 'text' && e.text)?.text;
+        const finalizedThinking = events.find((e) => e.type === 'thinking' && e.text)?.text;
+        const stepComplete = {
+            type: 'step_complete',
+            sessionId: event.sessionId,
+        };
+        if (finalizedText) {
+            stepComplete.resultText = finalizedText;
+        }
+        else if (finalizedThinking && !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);
+        this.textEventEmittedInTurn = false;
+        return events;
+    }
+    parseError(event) {
+        return [{
+                type: 'error',
+                errorMessage: event.message || event.data || 'Grok CLI error',
+                sessionId: event.sessionId,
+            }];
+    }
+}