tide-commander 1.148.0 → 1.150.0

package/dist/src/packages/server/claude/runner/stdout-pipeline.js

@@ -16,11 +16,30 @@ export class RunnerStdoutPipeline {
     // loops (respond → notify → respond → notify → ...). Once the notification is sent,
     // suppress all further text/tool output until a new user message arrives.
     notificationSent = new Set();
+    // Streaming thinking blocks share a uuid across token deltas. The UI marks a
+    // row as thinking via a single leading `[thinking]` prefix — only the first
+    // chunk of each stream should get it, otherwise merges become
+    // `[thinking] a[thinking] b…`.
+    thinkingStreamPrefixed = new Set();
+    // High-frequency token streams (Grok headless) produce dozens of tiny deltas
+    // per second. Coalesce them into ~one flush every STREAM_COALESCE_MS so the
+    // client doesn't remeasure/redraw the virtual list on every token.
+    streamCoalesce = new Map();
     constructor(deps) {
         this.backend = deps.backend;
         this.callbacks = deps.callbacks;
         this.bus = deps.bus;
     }
+    /** Backends that emit token-sized streaming-json deltas. */
+    shouldCoalesceStreaming() {
+        // Grok always streams token-sized NDJSON; Claude does with
+        // --include-partial-messages. Codex/OpenCode stream when their CLI
+        // surfaces item.updated / message.part.delta (stable-uuid parsers ready).
+        return (this.backend.name === 'grok' ||
+            this.backend.name === 'claude' ||
+            this.backend.name === 'codex' ||
+            this.backend.name === 'opencode');
+    }
     handleStdout(agentId, process) {
         return new Promise((resolve) => {
             const decoder = new StringDecoder('utf8');
@@ -134,25 +153,75 @@ export class RunnerStdoutPipeline {
             case 'init':
                 this.lastEmittedText.delete(agentId);
                 this.notificationSent.delete(agentId);
+                this.clearThinkingPrefixState(agentId);
                 this.callbacks.onOutput(agentId, `Session started: ${event.sessionId} (${event.model})`);
                 break;
             case 'text':
                 if (event.text) {
                     // Suppress consecutive identical text (extra safety for OpenCode agentic loop)
+                    // Skip for streaming chunks — token-level deltas are intentionally small and
+                    // may legitimately repeat, and they are merged client-side by uuid.
                     const prevText = this.lastEmittedText.get(agentId);
-                    if (prevText && prevText === event.text.trim()) {
+                    if (!event.isStreaming && prevText && prevText === event.text.trim()) {
                         log.log(`[text] Suppressing duplicate text for agent ${agentId.slice(0, 4)}`);
                         this.textEmittedInTurn.add(agentId);
                         break;
                     }
-                    this.lastEmittedText.set(agentId, event.text.trim());
-                    this.callbacks.onOutput(agentId, event.text, event.isStreaming, undefined, event.uuid);
+                    if (event.isStreaming && event.uuid && this.shouldCoalesceStreaming()) {
+                        this.enqueueStreamChunk(agentId, event.uuid, 'text', event.text);
+                    }
+                    else {
+                        // Flush any pending coalesced deltas before a final/non-stream emit
+                        // so the client never applies final full-text over a stale partial.
+                        if (event.uuid) {
+                            this.flushStreamCoalesce(`${agentId}:text:${event.uuid}`);
+                        }
+                        if (!event.isStreaming) {
+                            this.lastEmittedText.set(agentId, event.text.trim());
+                        }
+                        this.callbacks.onOutput(agentId, event.text, event.isStreaming, undefined, event.uuid);
+                    }
                     this.textEmittedInTurn.add(agentId);
                 }
                 break;
             case 'thinking':
                 if (event.text) {
-                    this.callbacks.onOutput(agentId, `[thinking] ${event.text}`, event.isStreaming, undefined, event.uuid);
+                    const streamKey = event.uuid ? `${agentId}:${event.uuid}` : undefined;
+                    if (!event.isStreaming) {
+                        if (event.uuid) {
+                            this.flushStreamCoalesce(`${agentId}:thinking:${event.uuid}`);
+                        }
+                        const thinkingOut = event.text.startsWith('[thinking]')
+                            ? event.text
+                            : `[thinking] ${event.text}`;
+                        this.callbacks.onOutput(agentId, thinkingOut, false, undefined, event.uuid);
+                        if (streamKey) {
+                            this.thinkingStreamPrefixed.delete(streamKey);
+                        }
+                        break;
+                    }
+                    // Streaming path
+                    if (event.uuid && this.shouldCoalesceStreaming()) {
+                        let chunk = event.text;
+                        if (streamKey && !this.thinkingStreamPrefixed.has(streamKey)) {
+                            this.thinkingStreamPrefixed.add(streamKey);
+                            chunk = `[thinking] ${event.text}`;
+                        }
+                        this.enqueueStreamChunk(agentId, event.uuid, 'thinking', chunk);
+                    }
+                    else {
+                        let thinkingOut = event.text;
+                        if (streamKey) {
+                            if (!this.thinkingStreamPrefixed.has(streamKey)) {
+                                this.thinkingStreamPrefixed.add(streamKey);
+                                thinkingOut = `[thinking] ${event.text}`;
+                            }
+                        }
+                        else if (!event.text.startsWith('[thinking]')) {
+                            thinkingOut = `[thinking] ${event.text}`;
+                        }
+                        this.callbacks.onOutput(agentId, thinkingOut, true, undefined, event.uuid);
+                    }
                 }
                 break;
             case 'tool_start': {
@@ -171,13 +240,27 @@ export class RunnerStdoutPipeline {
                 if (event.parentToolUseId) {
                     break;
                 }
+                const toolInput = event.toolInput;
+                const hasToolInput = !!toolInput
+                    && typeof toolInput === 'object'
+                    && !Array.isArray(toolInput)
+                    && Object.keys(toolInput).length > 0;
+                // Grok events.jsonl fires tool_started with name only (empty {}). Emitting
+                // those as terminal cards creates bare "LIST FILES" / "TASK OUTPUT" /
+                // "TODOWRITE" rows; chat_history re-emits the same uuid with full args.
+                // Still forward onEvent (above) for activity badges — only skip terminal text.
+                if (!hasToolInput && this.backend.name === 'grok') {
+                    break;
+                }
                 const toolStartSubName = event.subagentName || this.activeSubagentName.get(agentId);
                 this.callbacks.onOutput(agentId, `Using tool: ${event.toolName}`, false, toolStartSubName, event.uuid, {
                     toolName: event.toolName,
-                    toolInput: event.toolInput,
+                    toolInput,
                 });
-                if (event.toolInput) {
-                    this.callbacks.onOutput(agentId, `Tool input: ${JSON.stringify(event.toolInput)}`, false, toolStartSubName, event.uuid);
+                // Never emit "Tool input: {}" — empty object is truthy in JS and was
+                // producing useless sibling rows for every Grok early tool_start.
+                if (hasToolInput) {
+                    this.callbacks.onOutput(agentId, `Tool input: ${JSON.stringify(toolInput)}`, false, toolStartSubName, event.uuid);
                 }
                 break;
             }
@@ -195,6 +278,8 @@ export class RunnerStdoutPipeline {
                 break;
             }
             case 'step_complete': {
+                // Flush any pending coalesced stream chunks before finalizing the turn
+                this.flushAllStreamCoalesceForAgent(agentId);
                 const hasErrorResultText = this.isLikelyErrorResultText(event.resultText);
                 if (event.resultText && (!this.textEmittedInTurn.has(agentId) || hasErrorResultText)) {
                     log.log(`[step_complete] Emitting resultText as fallback (no prior text events) for agent ${agentId.slice(0, 4)}`);
@@ -203,6 +288,8 @@ export class RunnerStdoutPipeline {
                 else if (event.resultText) {
                     log.log(`[step_complete] Skipping resultText (already emitted via text events) for agent ${agentId.slice(0, 4)}`);
                 }
+                this.textEmittedInTurn.delete(agentId);
+                this.clearThinkingPrefixState(agentId);
                 if (event.permissionDenials && event.permissionDenials.length > 0) {
                     for (const denial of event.permissionDenials) {
                         // Suppress the "[System] Permission denied" line for the two tools
@@ -245,6 +332,60 @@ export class RunnerStdoutPipeline {
                 break;
         }
     }
+    clearThinkingPrefixState(agentId) {
+        const prefix = `${agentId}:`;
+        for (const key of this.thinkingStreamPrefixed) {
+            if (key.startsWith(prefix)) {
+                this.thinkingStreamPrefixed.delete(key);
+            }
+        }
+        // Drop any pending coalesced chunks for this agent
+        for (const [key, buf] of this.streamCoalesce) {
+            if (buf.agentId === agentId) {
+                if (buf.timer)
+                    clearTimeout(buf.timer);
+                this.streamCoalesce.delete(key);
+            }
+        }
+    }
+    static STREAM_COALESCE_MS = 80;
+    enqueueStreamChunk(agentId, uuid, kind, chunk) {
+        const key = `${agentId}:${kind}:${uuid}`;
+        let buf = this.streamCoalesce.get(key);
+        if (!buf) {
+            buf = { agentId, uuid, kind, chunks: [], timer: null };
+            this.streamCoalesce.set(key, buf);
+        }
+        buf.chunks.push(chunk);
+        if (buf.timer)
+            return;
+        buf.timer = setTimeout(() => {
+            this.flushStreamCoalesce(key);
+        }, RunnerStdoutPipeline.STREAM_COALESCE_MS);
+    }
+    flushStreamCoalesce(key) {
+        const buf = this.streamCoalesce.get(key);
+        if (!buf)
+            return;
+        if (buf.timer) {
+            clearTimeout(buf.timer);
+            buf.timer = null;
+        }
+        if (buf.chunks.length === 0) {
+            this.streamCoalesce.delete(key);
+            return;
+        }
+        const text = buf.chunks.join('');
+        buf.chunks = [];
+        this.streamCoalesce.delete(key);
+        this.callbacks.onOutput(buf.agentId, text, true, undefined, buf.uuid);
+    }
+    flushAllStreamCoalesceForAgent(agentId) {
+        const keys = [...this.streamCoalesce.keys()].filter((k) => k.startsWith(`${agentId}:`));
+        for (const key of keys) {
+            this.flushStreamCoalesce(key);
+        }
+    }
     isNotificationCurl(toolInput) {
         const cmd = typeof toolInput?.command === 'string' ? toolInput.command : '';
         return cmd.includes('/api/notify');

package/dist/src/packages/server/claude/runner/watchdog.js

@@ -71,6 +71,12 @@ export class RunnerWatchdog {
                         log.error(`🐕 [WATCHDOG] Agent ${agentId}: tailer drain failed: ${String(err)}`);
                     }
                     activeProcess.tmuxTailer?.stop();
+                    try {
+                        activeProcess.sideChannelStop?.();
+                    }
+                    catch {
+                        // ignore
+                    }
                     this.recordDeath({
                         agentId,
                         pid: activeProcess.process.pid ?? 0,
@@ -125,6 +131,12 @@ export class RunnerWatchdog {
                     timestamp: Date.now(),
                     stderr: this.lastStderr.get(agentId),
                 });
+                try {
+                    activeProcess.sideChannelStop?.();
+                }
+                catch {
+                    // ignore
+                }
                 this.activeProcesses.delete(agentId);
                 this.lastStderr.delete(agentId);
                 const remaining = this.activeProcesses.size;

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,206 @@ 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 };
+    }
+    // Timestamps: assign AFTER parse so the LAST message is file mtime and each
+    // prior message is 1s earlier. Using (mtime - 1h + lineIndex) put the whole
+    // history page ~50min behind wall-clock live events, so the merged
+    // history+live list buried all tools ABOVE the live stream (user pin-to-
+    // bottom only saw thinking + final text).
+    let fileMtimeMs = Date.now();
+    try {
+        fileMtimeMs = fs.statSync(chatHistoryPath).mtimeMs;
+    }
+    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 : '';
+        // Placeholder — rewritten below from file mtime once we know message count.
+        const ts = new Date(fileMtimeMs).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);
+    // Restamp so last message ≈ file mtime and order is preserved (1s steps).
+    const n = dedupedMessages.length;
+    if (n > 0) {
+        for (let i = 0; i < n; i++) {
+            dedupedMessages[i] = {
+                ...dedupedMessages[i],
+                timestamp: new Date(fileMtimeMs - (n - 1 - i) * 1000).toISOString(),
+            };
+        }
+    }
+    const last = n > 0 ? dedupedMessages[n - 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 +1653,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 +1960,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 +2170,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 = [];