tide-commander 0.84.2 → 0.85.0

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

@@ -5,6 +5,7 @@ import { createLogger } from '../utils/logger.js';
 const log = createLogger('CodexParser');
 let hasLoggedTurnAbortedLiveWarning = false;
 const MAX_DIFF_FILE_BYTES = 256 * 1024;
+const MAX_FALLBACK_EVENT_TEXT = 4000;
 function sanitizeCodexMessageText(text) {
     const hadTurnAborted = /<turn_aborted>[\s\S]*?<\/turn_aborted>/.test(text);
     const withoutTurnAborted = text.replace(/<turn_aborted>[\s\S]*?<\/turn_aborted>/g, '').trim();
@@ -71,10 +72,37 @@ function parseEnvelope(value) {
         type: asString(value.type),
         item: parseItem(value.item),
         usage: parseUsage(value.usage),
+        payload: parseResponsePayload(value.payload),
+    };
+}
+function parseSummaryArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .filter(isObject)
+        .map((entry) => ({
+        type: asString(entry.type),
+        text: asString(entry.text),
+    }));
+}
+function parseResponsePayload(payload) {
+    if (!isObject(payload))
+        return undefined;
+    return {
+        type: asString(payload.type),
+        status: asString(payload.status),
+        action: parseAction(payload.action),
+        item: parseItem(payload.item),
+        usage: parseUsage(payload.usage),
+        call_id: asString(payload.call_id),
+        name: asString(payload.name),
+        input: asString(payload.input),
+        output: asString(payload.output),
+        summary: parseSummaryArray(payload.summary),
     };
 }
 /**
- * Parses line-delimited JSON events from `codex exec --json` and maps them to
+ * Parses line-delimited JSON events from `codex exec --experimental-json` and maps them to
  * Tide runtime events.
  */
 export class CodexJsonEventParser {
@@ -108,6 +136,12 @@ export class CodexJsonEventParser {
         const event = parseEnvelope(rawEvent);
         if (!event?.type)
             return [];
+        if (event.type === 'event_msg') {
+            return this.parseEventMsg(rawEvent);
+        }
+        if (event.type === 'response_item') {
+            return this.parseResponseItem(event.payload);
+        }
         if (event.type === 'item.started') {
             return this.parseItemStarted(event.item);
         }
@@ -121,7 +155,171 @@ export class CodexJsonEventParser {
         if (event.type === 'turn.completed') {
             return this.parseTurnCompleted(event.usage);
         }
-        return [];
+        // Informational envelope events that don't need terminal display
+        if (event.type === 'turn.started' || event.type === 'thread.started') {
+            return [];
+        }
+        return [this.buildUnknownEventFallback(`Unhandled Codex event type: ${event.type}`, rawEvent)];
+    }
+    parseEventMsg(rawEvent) {
+        if (!isObject(rawEvent))
+            return [];
+        const payload = rawEvent.payload;
+        if (!isObject(payload))
+            return [];
+        const payloadType = asString(payload.type);
+        // token_count: Silent. Token accounting is handled by turn.completed.
+        if (payloadType === 'token_count') {
+            return [];
+        }
+        // agent_reasoning: Map to thinking event
+        if (payloadType === 'agent_reasoning') {
+            const text = asString(payload.text);
+            if (!text)
+                return [];
+            return [{ type: 'thinking', text, isStreaming: false }];
+        }
+        // turn_aborted: Silent. The interruption is already visible from the agent stopping.
+        if (payloadType === 'turn_aborted') {
+            return [];
+        }
+        // user_message / agent_message are handled via item.completed, skip if seen here
+        if (payloadType === 'user_message' || payloadType === 'agent_message') {
+            return [];
+        }
+        // task_complete: Display the final agent message as formatted text
+        if (payloadType === 'task_complete') {
+            const lastMsg = asString(payload.last_agent_message);
+            if (lastMsg) {
+                return [{ type: 'text', text: lastMsg, isStreaming: false }];
+            }
+            return [];
+        }
+        return [this.buildUnknownEventFallback(`Unhandled Codex event_msg type: ${payloadType}`, payload)];
+    }
+    parseResponseItem(payload) {
+        if (!payload?.type)
+            return [];
+        // Codex can emit web search activity wrapped in response_item payloads.
+        // Emit synthetic start/result so terminal streaming and history stay consistent.
+        if (payload.type === 'web_search_call') {
+            const toolName = 'web_search';
+            const toolInput = {
+                actionType: payload.action?.type,
+                actionQuery: payload.action?.query,
+                actionQueries: payload.action?.queries,
+                actionUrl: payload.action?.url,
+                status: payload.status,
+            };
+            if (payload.status === 'completed') {
+                return [
+                    { type: 'tool_start', toolName, toolInput },
+                    { type: 'tool_result', toolName, toolOutput: JSON.stringify(toolInput) },
+                ];
+            }
+            if (payload.status === 'in_progress' || payload.status === 'started') {
+                return [{ type: 'tool_start', toolName, toolInput }];
+            }
+            return [{ type: 'tool_result', toolName, toolOutput: JSON.stringify(toolInput) }];
+        }
+        // reasoning: Map summary text to thinking event
+        if (payload.type === 'reasoning') {
+            const text = this.extractReasoningSummaryText(payload);
+            if (!text)
+                return [];
+            return [{ type: 'thinking', text, isStreaming: false }];
+        }
+        // custom_tool_call: Map to tool_start (with special handling for apply_patch)
+        if (payload.type === 'custom_tool_call') {
+            return this.parseCustomToolCall(payload);
+        }
+        // custom_tool_call_output: Map to tool_result
+        if (payload.type === 'custom_tool_call_output') {
+            return this.parseCustomToolCallOutput(payload);
+        }
+        return [this.buildUnknownEventFallback(`Unhandled Codex response_item payload type: ${payload.type}`, payload)];
+    }
+    extractReasoningSummaryText(payload) {
+        if (!payload.summary || !Array.isArray(payload.summary))
+            return undefined;
+        const texts = payload.summary
+            .map((s) => s.text)
+            .filter((t) => Boolean(t));
+        return texts.length > 0 ? texts.join('\n') : undefined;
+    }
+    parseCustomToolCall(payload) {
+        const toolName = payload.name || 'unknown_tool';
+        const callId = payload.call_id;
+        const input = payload.input || '';
+        // Track tool name by call_id for correlating with custom_tool_call_output
+        if (callId) {
+            this.activeToolByItemId.set(callId, toolName);
+        }
+        // Special handling for apply_patch: generate synthetic Edit/Write events
+        if (toolName === 'apply_patch' && input) {
+            const inferredCalls = this.extractApplyPatchOperations(input);
+            if (inferredCalls.length > 0) {
+                const events = [];
+                for (const call of inferredCalls) {
+                    const filePath = this.stringField(call.toolInput.file_path);
+                    if (filePath) {
+                        const uiPath = this.normalizePathForUi(filePath);
+                        if (uiPath) {
+                            call.toolInput.file_path = uiPath;
+                        }
+                    }
+                    events.push({
+                        type: 'tool_start',
+                        toolName: call.toolName,
+                        toolInput: call.toolInput,
+                    });
+                    if (call.toolOutput) {
+                        events.push({
+                            type: 'tool_result',
+                            toolName: call.toolName,
+                            toolOutput: call.toolOutput,
+                        });
+                    }
+                }
+                return events;
+            }
+        }
+        // Generic tool_start for non-apply_patch or when patch parsing yields nothing
+        return [{
+                type: 'tool_start',
+                toolName,
+                toolInput: { input, call_id: callId },
+            }];
+    }
+    parseCustomToolCallOutput(payload) {
+        const callId = payload.call_id;
+        const toolName = callId
+            ? (this.activeToolByItemId.get(callId) ?? 'unknown_tool')
+            : 'unknown_tool';
+        if (callId) {
+            this.activeToolByItemId.delete(callId);
+        }
+        let toolOutput = payload.output || '';
+        // For apply_patch, extract the meaningful output from the JSON wrapper
+        if (toolName === 'apply_patch' && toolOutput) {
+            try {
+                const parsed = JSON.parse(toolOutput);
+                if (isObject(parsed)) {
+                    const outputText = asString(parsed.output);
+                    if (outputText) {
+                        toolOutput = outputText;
+                    }
+                }
+            }
+            catch {
+                // Use raw output string as-is
+            }
+        }
+        return [{
+                type: 'tool_result',
+                toolName: toolName === 'apply_patch' ? 'Edit' : toolName,
+                toolOutput,
+            }];
     }
     parseItemStarted(item) {
         if (!item?.type)
@@ -152,7 +350,7 @@ export class CodexJsonEventParser {
                 },
             ];
         }
-        return [];
+        return [this.buildUnknownEventFallback(`Unhandled Codex item.started type: ${item.type}`, item)];
     }
     parseItemCompleted(item) {
         if (!item?.type)
@@ -203,7 +401,12 @@ export class CodexJsonEventParser {
                 },
             ];
         }
-        return [];
+        // file_change: Silent. File change info is already captured from the
+        // command_execution or custom_tool_call that caused it.
+        if (item.type === 'file_change') {
+            return [];
+        }
+        return [this.buildUnknownEventFallback(`Unhandled Codex item.completed type: ${item.type}`, item)];
     }
     parseTurnCompleted(usage) {
         if (!usage)
@@ -223,6 +426,23 @@ export class CodexJsonEventParser {
         }
         return [event];
     }
+    buildUnknownEventFallback(prefix, payload) {
+        let serialized = '';
+        try {
+            serialized = JSON.stringify(payload);
+        }
+        catch {
+            serialized = String(payload);
+        }
+        if (serialized.length > MAX_FALLBACK_EVENT_TEXT) {
+            serialized = `${serialized.slice(0, MAX_FALLBACK_EVENT_TEXT)}...`;
+        }
+        return {
+            type: 'text',
+            text: `[codex-event] ${prefix}\n${serialized}`,
+            isStreaming: false,
+        };
+    }
     buildWebSearchToolInput(item) {
         return {
             query: item.query,

package/dist/src/packages/server/data/builtin-skills/full-notifications.js

@@ -2,7 +2,7 @@ export const fullNotifications = {
     slug: 'full-notifications',
     name: 'Full Notifications',
     description: 'Send notification via browser, android or in-app',
-    allowedTools: ['Bash(curl:*)', 'Bash(gdbus:*)'],
+    allowedTools: ['Bash(curl:*)'],
     content: `# Task Completion Notifications (MANDATORY)
 
 **IMPORTANT: You MUST send a notification automatically whenever you complete a task. This is not optional.**
@@ -14,31 +14,26 @@ export const fullNotifications = {
 
 ## Command Template
 \`\`\`bash
-curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"TITLE","message":"MESSAGE"}' & gdbus call --session --dest=org.freedesktop.Notifications --object-path=/org/freedesktop/Notifications --method=org.freedesktop.Notifications.Notify 'Tide Commander' 0 'ICON' 'TITLE' 'MESSAGE' '[]' '{}' 5000
+curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"TITLE","message":"MESSAGE"}'
 \`\`\`
 
 ## Examples by Type
 
 **Task Complete:**
 \`\`\`bash
-curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Task Complete","message":"Build succeeded"}' & gdbus call --session --dest=org.freedesktop.Notifications --object-path=/org/freedesktop/Notifications --method=org.freedesktop.Notifications.Notify 'Tide Commander' 0 'dialog-information' 'Task Complete' 'Build succeeded' '[]' '{}' 5000
+curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Task Complete","message":"Build succeeded"}'
 \`\`\`
 
 **Error/Attention Needed:**
 \`\`\`bash
-curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Error","message":"Build failed"}' & gdbus call --session --dest=org.freedesktop.Notifications --object-path=/org/freedesktop/Notifications --method=org.freedesktop.Notifications.Notify 'Tide Commander' 0 'dialog-warning' 'Error' 'Build failed' '[]' '{}' 5000
+curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Error","message":"Build failed"}'
 \`\`\`
 
 **Input Required:**
 \`\`\`bash
-curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Input Needed","message":"Which database?"}' & gdbus call --session --dest=org.freedesktop.Notifications --object-path=/org/freedesktop/Notifications --method=org.freedesktop.Notifications.Notify 'Tide Commander' 0 'dialog-question' 'Input Needed' 'Which database?' '[]' '{}' 5000
+curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/json" -d '{"agentId":"YOUR_AGENT_ID","title":"Input Needed","message":"Which database?"}'
 \`\`\`
 
-## Icons (gdbus)
-- \`dialog-information\` - Task complete
-- \`dialog-warning\` - Error/attention needed
-- \`dialog-question\` - Input required
-
 ## Rules
 - Replace \`YOUR_AGENT_ID\` with your actual agent ID from the system prompt
 - Keep messages under 50 characters
@@ -49,6 +44,5 @@ curl -s -X POST http://localhost:5174/api/notify -H "Content-Type: application/j
   - If task involves waiting for other agents to finish, do NOT notify until they confirm completion
   - Only notify when YOU have nothing more to do on this task
 - Send notification as your FINAL action after completing work
-- Do NOT skip this step - the user relies on notifications
-- The \`&\` runs both commands in parallel (curl for mobile/browser, gdbus for Linux desktop)`,
+- Do NOT skip this step - the user relies on notifications`,
 };

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

@@ -12,7 +12,7 @@ import { getClaudeProjectDir } from '../data/index.js';
 // Session listing is done inline for performance
 import { createLogger } from '../utils/logger.js';
 import { buildCustomAgentConfig } from '../websocket/handlers/command-handler.js';
-import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnabled, setEchoPromptEnabled } from '../services/system-prompt-service.js';
+import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnabled, setEchoPromptEnabled, getCodexBinaryPath, setCodexBinaryPath } from '../services/system-prompt-service.js';
 const log = createLogger('Routes');
 const router = Router();
 function runCommandWithTimeout(command, args, timeoutMs, cwd) {
@@ -482,4 +482,32 @@ router.post('/system-settings/echo-prompt', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// GET /api/system-settings/codex-binary - Get the codex binary path
+router.get('/system-settings/codex-binary', (_req, res) => {
+    try {
+        const binaryPath = getCodexBinaryPath();
+        res.json({ path: binaryPath });
+    }
+    catch (err) {
+        log.error(' Failed to get codex binary path:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/system-settings/codex-binary - Set the codex binary path
+router.post('/system-settings/codex-binary', (req, res) => {
+    try {
+        const { path: binaryPath } = req.body;
+        if (typeof binaryPath !== 'string') {
+            res.status(400).json({ error: 'path must be a string' });
+            return;
+        }
+        setCodexBinaryPath(binaryPath);
+        log.log(` Codex binary path updated: ${binaryPath || '(cleared)'}`);
+        res.json({ success: true, path: binaryPath });
+    }
+    catch (err) {
+        log.error(' Failed to set codex binary path:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 export default router;

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

@@ -97,7 +97,7 @@ const CONFIG_CATEGORIES = [
         id: 'system-settings',
         name: 'System Settings',
         description: 'Global system prompt and settings',
-        files: ['system-prompt.json', 'echo-prompt-setting.json'],
+        files: ['system-prompt.json', 'echo-prompt-setting.json', 'codex-binary-path.json'],
         sourceDir: 'data',
     },
 ];

package/dist/src/packages/server/services/system-prompt-service.js

@@ -115,3 +115,58 @@ export function setEchoPromptEnabled(enabled) {
         throw error;
     }
 }
+// ============================================================================
+// Codex Binary Path Setting
+// ============================================================================
+const CODEX_BINARY_FILE = path.join(DATA_DIR, 'codex-binary-path.json');
+/**
+ * Get the configured codex binary path (empty string if not set)
+ */
+export function getCodexBinaryPath() {
+    ensureDataDir();
+    try {
+        if (fs.existsSync(CODEX_BINARY_FILE)) {
+            const data = JSON.parse(fs.readFileSync(CODEX_BINARY_FILE, 'utf-8'));
+            return data.path;
+        }
+    }
+    catch (error) {
+        log.error(` Failed to load codex binary path: ${error.message}`);
+    }
+    return '';
+}
+/**
+ * Set the codex binary path
+ */
+export function setCodexBinaryPath(binaryPath) {
+    ensureDataDir();
+    const trimmed = binaryPath.trim();
+    if (trimmed) {
+        const data = {
+            path: trimmed,
+            updatedAt: Date.now(),
+        };
+        fs.writeFileSync(CODEX_BINARY_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        log.log(` Codex binary path set: ${trimmed}`);
+    }
+    else {
+        // Empty means clear
+        clearCodexBinaryPath();
+    }
+}
+/**
+ * Clear the codex binary path (revert to auto-detect)
+ */
+export function clearCodexBinaryPath() {
+    ensureDataDir();
+    try {
+        if (fs.existsSync(CODEX_BINARY_FILE)) {
+            fs.unlinkSync(CODEX_BINARY_FILE);
+            log.log(` Codex binary path cleared (will auto-detect)`);
+        }
+    }
+    catch (error) {
+        log.error(` Failed to clear codex binary path: ${error.message}`);
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "0.84.2",
+  "version": "0.85.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",