npm - tide-commander - Versions diffs - 0.69.2 → 0.69.4 - Mend

tide-commander 0.69.2 → 0.69.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/assets/main-D-4CYuC3.js +299 -0
package/dist/assets/main-Zi2pcuPE.css +1 -0
package/dist/index.html +2 -2
package/dist/src/packages/server/routes/files.js +22 -6
package/dist/src/packages/server/services/runtime-service.js +0 -19
package/dist/src/packages/server/services/subagent-jsonl-watcher.js +413 -0
package/dist/src/packages/server/websocket/listeners/runtime-listeners.js +13 -0
package/package.json +1 -1
package/dist/assets/main-BOFXGJQm.css +0 -1
package/dist/assets/main-DkIjeEeR.js +0 -299

package/dist/index.html CHANGED Viewed

@@ -22,11 +22,11 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-DkIjeEeR.js"></script>
+    <script type="module" crossorigin src="/assets/main-D-4CYuC3.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-B5Qt9EMX.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-uS-d4TUT.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-DJ4p3FLF.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-BOFXGJQm.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-Zi2pcuPE.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/server/routes/files.js CHANGED Viewed

@@ -1243,7 +1243,7 @@ router.post('/git-pull', async (req, res) => {
             return;
         }
         try {
-            let cmd = 'git pull';
+            let cmd = 'git pull --no-rebase';
             if (remote)
                 cmd += ` "${remote}"`;
             if (branch)
@@ -1252,15 +1252,31 @@ router.post('/git-pull', async (req, res) => {
             res.json({ success: true, output: output.trim() });
         }
         catch (err) {
-            const stderr = err.stderr?.toString() || err.message || '';
-            if (stderr.includes('CONFLICT')) {
-                res.status(409).json({ success: false, error: 'Merge conflict detected during pull. Resolve conflicts manually.' });
+            const stderr = err.stderr?.toString() || '';
+            const stdout = err.stdout?.toString() || '';
+            const combined = stdout + '\n' + stderr;
+            if (combined.includes('CONFLICT') || combined.includes('Automatic merge failed')) {
+                // Parse conflict file paths from output (same as merge endpoint)
+                const conflicts = [];
+                const conflictRegex = /CONFLICT \([^)]+\): Merge conflict in (.+)/g;
+                let match;
+                while ((match = conflictRegex.exec(combined)) !== null) {
+                    conflicts.push(path.join(gitRoot, match[1].trim()));
+                }
+                const bothRegex = /CONFLICT \([^)]+\):.+?(?:both modified|both added):\s*(.+)/g;
+                while ((match = bothRegex.exec(combined)) !== null) {
+                    const conflictPath = path.join(gitRoot, match[1].trim());
+                    if (!conflicts.includes(conflictPath)) {
+                        conflicts.push(conflictPath);
+                    }
+                }
+                res.json({ success: false, output: combined.trim(), conflicts });
             }
-            else if (stderr.includes('ETIMEDOUT') || stderr.includes('Could not resolve')) {
+            else if (combined.includes('ETIMEDOUT') || combined.includes('Could not resolve')) {
                 res.status(504).json({ success: false, error: 'Network error. Check your connection.' });
             }
             else {
-                res.status(500).json({ success: false, error: stderr.trim() || err.message });
+                res.status(500).json({ success: false, error: (stderr || stdout).trim() || err.message });
             }
         }
     }

package/dist/src/packages/server/services/runtime-service.js CHANGED Viewed

@@ -79,24 +79,6 @@ function emit(event, ...args) {
         listeners.forEach((listener) => listener(...args));
     }
 }
-function scheduleSilentContextRefresh(agentId, reason) {
-    setTimeout(() => {
-        if (reason === 'step_complete') {
-            log.log(`[step_complete] Sending silent /context for agent ${agentId}`);
-        }
-        if (reason === 'handle_complete') {
-            log.log(`[handleComplete] Triggering fallback /context refresh for agent ${agentId}`);
-        }
-        sendSilentCommand(agentId, '/context').catch((err) => {
-            if (reason === 'step_complete') {
-                log.log(`[step_complete] Silent /context failed for ${agentId}: ${err}`);
-            }
-            else {
-                log.log(`[handleComplete] Fallback /context failed for ${agentId}: ${err}`);
-            }
-        });
-    }, 300);
-}
 const commandExecution = createRuntimeCommandExecution({
     log,
     getRunner,
@@ -117,7 +99,6 @@ const runtimeEvents = createRuntimeEventHandlers({
     emitError: (agentId, error) => emit('error', agentId, error),
     parseUsageOutput: (raw) => parseUsageOutput(raw),
     executeCommand: (agentId, command, systemPrompt, forceNewSession) => commandExecution.executeCommand(agentId, command, systemPrompt, forceNewSession),
-    scheduleSilentContextRefresh,
 });
 const statusSync = createRuntimeStatusSync({
     log,

package/dist/src/packages/server/services/subagent-jsonl-watcher.js ADDED Viewed

@@ -0,0 +1,413 @@
+/**
+ * Subagent JSONL File Watcher
+ *
+ * Watches Claude Code's subagent JSONL files for real-time activity streaming.
+ * Files are located at: ~/.claude/projects/<encoded-project>/<sessionId>/subagents/agent-<id>.jsonl
+ *
+ * Each JSONL line contains a message entry (user prompt, assistant text, tool_use, tool_result).
+ * We parse these and broadcast them to the UI for real-time subagent visibility.
+ *
+ * Lifecycle: The watcher starts when a Task tool spawns a subagent. For team agents,
+ * the Task tool returns immediately but the subagent process keeps running and writing
+ * to the JSONL file. The watcher uses idle-based auto-stop: it keeps running as long as
+ * the file is growing, and stops after IDLE_TIMEOUT_MS of no new content.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createLogger } from '../utils/logger.js';
+import { encodeProjectPath } from '../claude/session-loader.js';
+const log = createLogger('SubagentJSONL');
+const MAX_ENTRIES_PER_BROADCAST = 20;
+const IDLE_TIMEOUT_MS = 180_000; // Stop after 3 minutes of no file changes (subagents can run long builds)
+const POLL_INTERVAL_MS = 2_000; // Poll file every 2s (fallback if fs.watch misses events)
+const MAX_WATCH_DURATION_MS = 900_000; // Hard limit: 15 minutes max per watcher
+// Key param extraction per tool name
+const TOOL_KEY_PARAMS = {
+    Bash: 'command',
+    Read: 'file_path',
+    Edit: 'file_path',
+    Write: 'file_path',
+    Grep: 'pattern',
+    Glob: 'pattern',
+    WebSearch: 'query',
+    WebFetch: 'url',
+    Task: 'description',
+    NotebookEdit: 'notebook_path',
+};
+const activeWatchers = new Map();
+/**
+ * Get the subagents directory for a given agent's session
+ */
+export function getSubagentsDir(cwd, sessionId) {
+    const encoded = encodeProjectPath(cwd);
+    return path.join(os.homedir(), '.claude', 'projects', encoded, sessionId, 'subagents');
+}
+/**
+ * Start watching for a subagent's JSONL file
+ */
+export function startWatching(toolUseId, parentAgentId, subagentsDir, onBroadcast) {
+    if (activeWatchers.has(toolUseId)) {
+        log.warn(`[Watcher] Already watching for toolUseId=${toolUseId}`);
+        return;
+    }
+    const watcher = {
+        toolUseId,
+        parentAgentId,
+        subagentsDir,
+        readPosition: 0,
+        lineBuffer: '',
+        pendingEntries: [],
+        onBroadcast,
+        stopped: false,
+        lastReadTime: Date.now(),
+    };
+    activeWatchers.set(toolUseId, watcher);
+    log.log(`[Watcher] Starting watch for toolUseId=${toolUseId}, dir=${subagentsDir}`);
+    // Set a hard max duration to prevent leaks
+    watcher.maxTimer = setTimeout(() => {
+        log.log(`[Watcher] Max duration reached for toolUseId=${toolUseId}, stopping`);
+        doStop(watcher);
+    }, MAX_WATCH_DURATION_MS);
+    // Try to find existing files first, then watch for new ones
+    tryFindAndWatchFile(watcher);
+}
+/**
+ * Signal that the subagent's Task tool has completed.
+ * For team agents, the Task returns immediately but the subagent keeps running.
+ * We don't stop the watcher - it will auto-stop when the file goes idle.
+ */
+export function stopWatching(toolUseId) {
+    const watcher = activeWatchers.get(toolUseId);
+    if (!watcher)
+        return;
+    // Just do a read to catch any pending content, but DON'T stop.
+    // The idle timeout will handle actual cleanup.
+    if (watcher.jsonlPath) {
+        readNewLines(watcher);
+    }
+    log.log(`[Watcher] Task completed for toolUseId=${toolUseId}, watcher continues (idle-based stop)`);
+}
+/**
+ * Actually stop and cleanup a watcher
+ */
+function doStop(watcher) {
+    if (watcher.stopped)
+        return;
+    watcher.stopped = true;
+    // Final read
+    if (watcher.jsonlPath) {
+        readNewLines(watcher);
+    }
+    flushEntries(watcher);
+    // Cleanup all timers and watchers
+    watcher.dirWatcher?.close();
+    watcher.fileWatcher?.close();
+    if (watcher.broadcastTimer)
+        clearTimeout(watcher.broadcastTimer);
+    if (watcher.pollTimer)
+        clearInterval(watcher.pollTimer);
+    if (watcher.idleTimer)
+        clearTimeout(watcher.idleTimer);
+    if (watcher.maxTimer)
+        clearTimeout(watcher.maxTimer);
+    activeWatchers.delete(watcher.toolUseId);
+    log.log(`[Watcher] Stopped watching toolUseId=${watcher.toolUseId}`);
+}
+/**
+ * Stop all watchers (server shutdown)
+ */
+export function stopAll() {
+    for (const watcher of activeWatchers.values()) {
+        doStop(watcher);
+    }
+}
+/**
+ * Reset the idle timer - called whenever new content is read
+ */
+function resetIdleTimer(watcher) {
+    if (watcher.idleTimer)
+        clearTimeout(watcher.idleTimer);
+    watcher.idleTimer = setTimeout(() => {
+        log.log(`[Watcher] Idle timeout for toolUseId=${watcher.toolUseId}, stopping`);
+        doStop(watcher);
+    }, IDLE_TIMEOUT_MS);
+}
+/**
+ * Try to find an existing JSONL file or watch the directory for new ones
+ */
+function tryFindAndWatchFile(watcher) {
+    const { subagentsDir } = watcher;
+    // Check if directory exists yet
+    if (!fs.existsSync(subagentsDir)) {
+        // Directory doesn't exist yet - watch parent for it to appear
+        const parentDir = path.dirname(subagentsDir);
+        if (!fs.existsSync(parentDir)) {
+            // Session directory doesn't exist either - retry periodically
+            const retryInterval = setInterval(() => {
+                if (watcher.stopped) {
+                    clearInterval(retryInterval);
+                    return;
+                }
+                if (fs.existsSync(subagentsDir)) {
+                    clearInterval(retryInterval);
+                    watchDirectory(watcher);
+                }
+            }, 500);
+            // Give up after 30 seconds
+            setTimeout(() => clearInterval(retryInterval), 30000);
+            return;
+        }
+        // Watch parent directory for subagents/ to appear
+        try {
+            const parentWatcher = fs.watch(parentDir, (eventType, filename) => {
+                if (watcher.stopped)
+                    return;
+                if (filename === 'subagents' && fs.existsSync(subagentsDir)) {
+                    parentWatcher.close();
+                    watchDirectory(watcher);
+                }
+            });
+            parentWatcher.on('error', () => parentWatcher.close());
+        }
+        catch {
+            log.warn(`[Watcher] Failed to watch parent dir: ${parentDir}`);
+        }
+        return;
+    }
+    // Directory exists - look for existing files or watch for new ones
+    watchDirectory(watcher);
+}
+/**
+ * Watch the subagents directory for JSONL files
+ */
+function watchDirectory(watcher) {
+    if (watcher.stopped)
+        return;
+    const { subagentsDir } = watcher;
+    // Check for existing .jsonl files
+    try {
+        const files = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
+        if (files.length > 0) {
+            // Pick the most recently modified file
+            let newest = files[0];
+            let newestMtime = 0;
+            for (const f of files) {
+                try {
+                    const stat = fs.statSync(path.join(subagentsDir, f));
+                    if (stat.mtimeMs > newestMtime) {
+                        newestMtime = stat.mtimeMs;
+                        newest = f;
+                    }
+                }
+                catch { /* skip */ }
+            }
+            startFileWatch(watcher, path.join(subagentsDir, newest));
+            return;
+        }
+    }
+    catch { /* directory may have been removed */ }
+    // No files yet - watch for new ones
+    try {
+        watcher.dirWatcher = fs.watch(subagentsDir, (eventType, filename) => {
+            if (watcher.stopped)
+                return;
+            if (filename && filename.endsWith('.jsonl') && !watcher.jsonlPath) {
+                const filePath = path.join(subagentsDir, filename);
+                if (fs.existsSync(filePath)) {
+                    watcher.dirWatcher?.close();
+                    watcher.dirWatcher = undefined;
+                    startFileWatch(watcher, filePath);
+                }
+            }
+        });
+        watcher.dirWatcher.on('error', () => {
+            watcher.dirWatcher?.close();
+            watcher.dirWatcher = undefined;
+        });
+    }
+    catch {
+        log.warn(`[Watcher] Failed to watch directory: ${subagentsDir}`);
+    }
+}
+/**
+ * Start watching a specific JSONL file for new content
+ */
+function startFileWatch(watcher, filePath) {
+    if (watcher.stopped)
+        return;
+    watcher.jsonlPath = filePath;
+    log.log(`[Watcher] Found JSONL file: ${filePath} for toolUseId=${watcher.toolUseId}`);
+    // Read existing content
+    readNewLines(watcher);
+    // Start idle timer
+    resetIdleTimer(watcher);
+    // Watch for changes via fs.watch
+    try {
+        watcher.fileWatcher = fs.watch(filePath, (eventType) => {
+            if (watcher.stopped)
+                return;
+            if (eventType === 'change') {
+                readNewLines(watcher);
+            }
+        });
+        watcher.fileWatcher.on('error', () => {
+            watcher.fileWatcher?.close();
+            watcher.fileWatcher = undefined;
+        });
+    }
+    catch {
+        log.warn(`[Watcher] Failed to watch file: ${filePath}`);
+    }
+    // Also poll periodically as fallback (fs.watch can miss events on some systems)
+    watcher.pollTimer = setInterval(() => {
+        if (watcher.stopped)
+            return;
+        readNewLines(watcher);
+    }, POLL_INTERVAL_MS);
+}
+/**
+ * Read new lines from the JSONL file since last read position
+ */
+function readNewLines(watcher) {
+    if (!watcher.jsonlPath)
+        return;
+    let fd;
+    try {
+        fd = fs.openSync(watcher.jsonlPath, 'r');
+        const stat = fs.fstatSync(fd);
+        if (stat.size <= watcher.readPosition) {
+            fs.closeSync(fd);
+            return;
+        }
+        const bytesToRead = stat.size - watcher.readPosition;
+        const buffer = Buffer.alloc(bytesToRead);
+        fs.readSync(fd, buffer, 0, bytesToRead, watcher.readPosition);
+        fs.closeSync(fd);
+        fd = undefined;
+        watcher.readPosition = stat.size;
+        watcher.lastReadTime = Date.now();
+        // Reset idle timer since we got new content
+        resetIdleTimer(watcher);
+        // Split into lines, handling partial lines
+        const text = watcher.lineBuffer + buffer.toString('utf8');
+        const lines = text.split('\n');
+        // Last element may be incomplete - save as buffer
+        watcher.lineBuffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const entries = parseLine(trimmed);
+            if (entries.length > 0) {
+                watcher.pendingEntries.push(...entries);
+            }
+        }
+        // Debounce broadcast
+        scheduleBroadcast(watcher);
+    }
+    catch {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+        // File may have been removed or not ready
+    }
+}
+/**
+ * Schedule a debounced broadcast of pending entries
+ */
+function scheduleBroadcast(watcher) {
+    if (watcher.broadcastTimer)
+        return; // Already scheduled
+    watcher.broadcastTimer = setTimeout(() => {
+        watcher.broadcastTimer = undefined;
+        flushEntries(watcher);
+    }, 300);
+}
+/**
+ * Flush pending entries to the broadcast callback
+ */
+function flushEntries(watcher) {
+    if (watcher.pendingEntries.length === 0)
+        return;
+    const entries = watcher.pendingEntries.splice(0, MAX_ENTRIES_PER_BROADCAST);
+    // If there are still more, keep the rest for next flush
+    if (watcher.pendingEntries.length > 0) {
+        scheduleBroadcast(watcher);
+    }
+    watcher.onBroadcast(watcher.toolUseId, watcher.parentAgentId, entries);
+}
+/**
+ * Parse a single JSONL line into SubagentStreamEntry items
+ */
+function parseLine(line) {
+    const entries = [];
+    try {
+        const data = JSON.parse(line);
+        const message = data.message;
+        if (!message || !message.content)
+            return entries;
+        const timestamp = data.timestamp || new Date().toISOString();
+        const contentArray = Array.isArray(message.content) ? message.content : [];
+        // Skip initial user prompts (the task delegation message)
+        if (data.type === 'user' && message.role === 'user') {
+            // Check if this is a tool_result
+            for (const block of contentArray) {
+                if (block.type === 'tool_result') {
+                    const resultText = typeof block.content === 'string'
+                        ? block.content
+                        : Array.isArray(block.content)
+                            ? block.content.filter((b) => b.type === 'text').map((b) => b.text).join(' ')
+                            : '';
+                    if (resultText) {
+                        entries.push({
+                            type: 'tool_result',
+                            timestamp,
+                            resultPreview: resultText.slice(0, 200),
+                            isError: block.is_error === true,
+                            toolUseId: block.tool_use_id,
+                        });
+                    }
+                }
+            }
+            return entries;
+        }
+        // Parse assistant messages
+        if (data.type === 'assistant' && message.role === 'assistant') {
+            for (const block of contentArray) {
+                if (block.type === 'text' && block.text) {
+                    const text = block.text.trim();
+                    if (text) {
+                        entries.push({
+                            type: 'text',
+                            timestamp,
+                            text: text.slice(0, 200),
+                        });
+                    }
+                }
+                else if (block.type === 'tool_use') {
+                    const toolName = block.name || 'Unknown';
+                    const input = block.input || {};
+                    const keyParamName = TOOL_KEY_PARAMS[toolName];
+                    const keyParam = keyParamName && input[keyParamName]
+                        ? String(input[keyParamName]).slice(0, 120)
+                        : undefined;
+                    entries.push({
+                        type: 'tool_use',
+                        timestamp,
+                        toolName,
+                        toolKeyParam: keyParam,
+                        toolUseId: block.id,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // Invalid JSON line - skip
+    }
+    return entries;
+}

package/dist/src/packages/server/websocket/listeners/runtime-listeners.js CHANGED Viewed

@@ -6,6 +6,7 @@ import { parseAllFormats } from '../handlers/agent-handler.js';
 import { agentService, runtimeService } from '../../services/index.js';
 import { logger, formatToolActivity } from '../../utils/index.js';
 import { parseBossDelegation, parseBossSpawn, getBossForSubordinate, clearDelegation } from '../handlers/boss-response-handler.js';
+import { startWatching as startJsonlWatching, stopWatching as stopJsonlWatching, getSubagentsDir } from '../../services/subagent-jsonl-watcher.js';
 const log = logger.ws;
 const MAX_SYNTHETIC_DIFF_FILE_BYTES = 256 * 1024;
 export function setupRuntimeListeners(ctx) {
@@ -47,6 +48,16 @@ export function setupRuntimeListeners(ctx) {
                     });
                     ctx.sendActivity(agentId, `Spawned subagent: ${subagent.name} (${subagent.subagentType})`);
                     log.log(`[Subagent] Broadcast subagent_started: ${subagent.name} (${subagent.id})`);
+                    // Start streaming JSONL file for this subagent
+                    if (parentAgent?.sessionId) {
+                        const subagentsDir = getSubagentsDir(parentAgent.cwd, parentAgent.sessionId);
+                        startJsonlWatching(event.toolUseId, agentId, subagentsDir, (toolUseId, parentAgentId, entries) => {
+                            ctx.broadcast({
+                                type: 'subagent_stream',
+                                payload: { toolUseId, parentAgentId, entries },
+                            });
+                        });
+                    }
                 }
             }
         }
@@ -84,6 +95,8 @@ export function setupRuntimeListeners(ctx) {
                 },
             });
             log.log(`[Subagent] Broadcast subagent_completed for toolUseId=${event.toolUseId}, name=${event.subagentName || 'unknown'}, stats=${event.subagentStats ? `${event.subagentStats.durationMs}ms/${event.subagentStats.tokensUsed}tok/${event.subagentStats.toolUseCount}tools` : 'none'}`);
+            // Stop streaming JSONL file for this subagent
+            stopJsonlWatching(event.toolUseId);
         }
         // Forward subagent internal tool activity to client (events with parentToolUseId)
         if (event.parentToolUseId && event.type === 'tool_start' && event.toolName !== 'Task') {

package/package.json CHANGED Viewed

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