tide-commander 1.148.0 → 1.149.0

package/dist/src/packages/server/claude/session-loader.js

@@ -52,6 +52,27 @@ const OPENCODE_TOOL_NAME_MAP = {
 function normalizeOpencodeToolName(raw) {
     return OPENCODE_TOOL_NAME_MAP[raw.toLowerCase()] || raw;
 }
+// Grok CLI tool names → Tide UI names (keep in sync with grok/session-watcher.ts)
+const GROK_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',
+};
+function normalizeGrokToolName(raw) {
+    return GROK_TOOL_NAME_MAP[raw.toLowerCase()] || raw;
+}
+const GROK_DIR = path.join(os.homedir(), '.grok');
+const GROK_SESSIONS_DIR = path.join(GROK_DIR, 'sessions');
 const codexSessionFileById = new Map();
 const opencodeSessionFileById = new Map();
 let cachedOpencodeDb = null;
@@ -452,6 +473,49 @@ function findOpencodeSessionFile(sessionId) {
     }
     return null;
 }
+/**
+ * Locate a Grok session directory for (cwd, sessionId).
+ * Grok keys projects by encodeURIComponent(absolute cwd) under ~/.grok/sessions/.
+ */
+function findGrokSessionDir(cwd, sessionId) {
+    if (!sessionId)
+        return null;
+    const candidates = new Set();
+    try {
+        candidates.add(path.resolve(cwd));
+    }
+    catch {
+        // ignore
+    }
+    candidates.add(cwd.replace(/\/+$/, ''));
+    candidates.add(cwd);
+    for (const c of candidates) {
+        if (!c)
+            continue;
+        const dir = path.join(GROK_SESSIONS_DIR, encodeURIComponent(c), sessionId);
+        const chatPath = path.join(dir, 'chat_history.jsonl');
+        if (fs.existsSync(chatPath)) {
+            return dir;
+        }
+    }
+    // Fallback: scan all project keys for this session id (slower, rare)
+    if (!fs.existsSync(GROK_SESSIONS_DIR))
+        return null;
+    try {
+        for (const entry of fs.readdirSync(GROK_SESSIONS_DIR, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const dir = path.join(GROK_SESSIONS_DIR, entry.name, sessionId);
+            if (fs.existsSync(path.join(dir, 'chat_history.jsonl'))) {
+                return dir;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
 function resolveSessionFile(cwd, sessionId) {
     const claudeFile = path.join(getProjectDir(cwd), `${sessionId}.jsonl`);
     if (fs.existsSync(claudeFile)) {
@@ -473,6 +537,14 @@ function resolveSessionFile(cwd, sessionId) {
     if (opencodeFile && fs.existsSync(opencodeFile)) {
         return { provider: 'opencode', filePath: opencodeFile };
     }
+    const grokDir = findGrokSessionDir(cwd, sessionId);
+    if (grokDir) {
+        return {
+            provider: 'grok',
+            filePath: path.join(grokDir, 'chat_history.jsonl'),
+            grokSessionDir: grokDir,
+        };
+    }
     return null;
 }
 /**
@@ -1374,6 +1446,191 @@ async function parseOpencodeSessionMessages(sessionFilePath) {
         lastMessageTimestamp: last?.timestamp ? new Date(last.timestamp) : null,
     };
 }
+function extractGrokTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const b = block;
+        if (b.type === 'text' && typeof b.text === 'string') {
+            parts.push(b.text);
+        }
+    }
+    return parts.join('\n');
+}
+/** Prefer the Tide-injected <user_query> body when present. */
+function extractGrokUserDisplayText(content) {
+    const raw = extractGrokTextContent(content).trim();
+    if (!raw)
+        return '';
+    const queryMatch = raw.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/i);
+    if (queryMatch?.[1]) {
+        return queryMatch[1].trim();
+    }
+    return raw;
+}
+function parseGrokToolArguments(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 {};
+}
+/**
+ * Parse Grok chat_history.jsonl into Tide SessionMessages.
+ * chat_history has no per-line timestamps — we synthesize monotonic ISO times
+ * so the client sort order matches file order.
+ */
+function parseGrokSessionMessages(chatHistoryPath) {
+    const messages = [];
+    if (!fs.existsSync(chatHistoryPath)) {
+        return { messages: [], lastMessageType: null, lastMessageTimestamp: null };
+    }
+    // Base clock from file mtime so relative times feel recent; +1s per line for order.
+    let baseMs = Date.now() - 3_600_000;
+    try {
+        baseMs = fs.statSync(chatHistoryPath).mtimeMs - 3_600_000;
+    }
+    catch {
+        // ignore
+    }
+    const content = fs.readFileSync(chatHistoryPath, 'utf-8');
+    const lines = content.split('\n');
+    let lineIndex = 0;
+    const toolUseIdToName = new Map();
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        lineIndex += 1;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = typeof entry.type === 'string' ? entry.type : '';
+        const ts = new Date(baseMs + lineIndex * 1000).toISOString();
+        // Skip system prompt and synthetic MCP/system-reminder injections
+        if (type === 'system')
+            continue;
+        if (type === 'user' && entry.synthetic_reason === 'system_reminder')
+            continue;
+        if (type === 'user') {
+            const text = extractGrokUserDisplayText(entry.content);
+            if (!text)
+                continue;
+            // Skip pure scaffolding (user_info / system-reminder without user_query)
+            if (text.startsWith('<user_info>') ||
+                text.startsWith('<system-reminder>') ||
+                (text.includes('<system-reminder>') && !text.includes('<user_query>'))) {
+                continue;
+            }
+            messages.push({
+                type: 'user',
+                content: text,
+                timestamp: ts,
+                uuid: `grok-user-${lineIndex}`,
+            });
+            continue;
+        }
+        if (type === 'reasoning') {
+            // Optional thinking summaries — surface as assistant thinking lines
+            const summary = entry.summary;
+            let thinking = '';
+            if (Array.isArray(summary)) {
+                thinking = summary
+                    .map((s) => {
+                    if (s && typeof s === 'object' && typeof s.text === 'string') {
+                        return s.text;
+                    }
+                    return '';
+                })
+                    .filter(Boolean)
+                    .join('\n');
+            }
+            if (thinking) {
+                messages.push({
+                    type: 'assistant',
+                    content: `[thinking] ${thinking}`,
+                    timestamp: ts,
+                    uuid: typeof entry.id === 'string' ? entry.id : `grok-reasoning-${lineIndex}`,
+                });
+            }
+            continue;
+        }
+        if (type === 'assistant') {
+            const text = typeof entry.content === 'string' ? entry.content : extractGrokTextContent(entry.content);
+            if (text.trim()) {
+                messages.push({
+                    type: 'assistant',
+                    content: text,
+                    timestamp: ts,
+                    uuid: `grok-assistant-${lineIndex}`,
+                });
+            }
+            const toolCalls = entry.tool_calls;
+            if (Array.isArray(toolCalls)) {
+                for (let ti = 0; ti < toolCalls.length; ti++) {
+                    const call = toolCalls[ti];
+                    const callId = call.id || `grok-call-${lineIndex}-${ti}`;
+                    const toolName = normalizeGrokToolName(call.name || 'unknown');
+                    toolUseIdToName.set(callId, toolName);
+                    messages.push({
+                        type: 'tool_use',
+                        content: '',
+                        timestamp: ts,
+                        uuid: callId,
+                        toolName,
+                        toolInput: parseGrokToolArguments(call.arguments),
+                        toolUseId: callId,
+                    });
+                }
+            }
+            continue;
+        }
+        if (type === 'tool_result') {
+            const callId = typeof entry.tool_call_id === 'string' ? entry.tool_call_id : `grok-result-${lineIndex}`;
+            const content = typeof entry.content === 'string'
+                ? entry.content
+                : entry.content != null
+                    ? JSON.stringify(entry.content)
+                    : '';
+            messages.push({
+                type: 'tool_result',
+                content,
+                timestamp: ts,
+                uuid: `${callId}-result`,
+                toolUseId: callId,
+                toolName: toolUseIdToName.get(callId) || 'unknown',
+            });
+        }
+    }
+    const dedupedMessages = deduplicateSessionMessages(messages);
+    const last = dedupedMessages.length > 0 ? dedupedMessages[dedupedMessages.length - 1] : null;
+    return {
+        messages: dedupedMessages,
+        lastMessageType: last?.type ?? null,
+        lastMessageTimestamp: last?.timestamp ? new Date(last.timestamp) : null,
+    };
+}
 async function parseSessionMessages(resolved) {
     if (resolved.provider === 'opencode') {
         if (resolved.opencodeDbSessionId) {
@@ -1381,6 +1638,9 @@ async function parseSessionMessages(resolved) {
         }
         return parseOpencodeSessionMessages(resolved.filePath);
     }
+    if (resolved.provider === 'grok') {
+        return parseGrokSessionMessages(resolved.filePath);
+    }
     const messages = [];
     const toolUseIdToName = new Map();
     const fileStream = fs.createReadStream(resolved.filePath);
@@ -1685,12 +1945,16 @@ const PROVIDER_PROCESS_PATTERNS = {
     claude: '(claude$|/claude( |$)|claude\\.cmd|claude\\.exe)',
     codex: '(codex($| )|/codex( |$)|codex\\.cmd|codex\\.exe|codex\\.js|@openai/codex)',
     opencode: '(opencode($| )|/opencode( |$)|opencode\\.cmd|opencode\\.exe)',
+    // Match `grok` CLI but not unrelated tools with "grok" in the path/name as a substring of a longer token.
+    grok: '(^|/)grok($| )|grok\\.cmd|grok\\.exe',
 };
 function providerDisplayName(provider) {
     if (provider === 'codex')
         return 'Codex';
     if (provider === 'opencode')
         return 'OpenCode';
+    if (provider === 'grok')
+        return 'Grok';
     return 'Claude';
 }
 function getProviderProcessPids(provider, execSync) {
@@ -1891,6 +2155,22 @@ export async function findOpencodeProcessPidInCwd(cwd) {
 export async function killOpencodeProcessInCwd(cwd) {
     return killProviderProcessInCwd(cwd, 'opencode');
 }
+/**
+ * Check if there's a Grok process running in a specific directory.
+ */
+export async function isGrokProcessRunningInCwd(cwd) {
+    return isProviderProcessRunningInCwd(cwd, 'grok');
+}
+export async function findGrokProcessPidInCwd(cwd) {
+    return findProviderProcessPidInCwd(cwd, 'grok');
+}
+/**
+ * Kill any Grok process running in the specified directory.
+ * Returns true if a process was found and killed.
+ */
+export async function killGrokProcessInCwd(cwd) {
+    return killProviderProcessInCwd(cwd, 'grok');
+}
 export async function loadToolHistory(cwd, sessionId, agentId, agentName, limit = 100) {
     const toolExecutions = [];
     const fileChanges = [];

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,231 @@
+/**
+ * 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;
+    }
+    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';