npm - claude-remote-cli - Versions diffs - 3.1.1 → 3.3.0 - Mend

claude-remote-cli 3.1.1 → 3.3.0

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 (16) hide show

package/dist/frontend/assets/index-BNLfnaOa.css +32 -0
package/dist/frontend/assets/index-ggOT9Hda.js +47 -0
package/dist/frontend/index.html +2 -2
package/dist/server/git.js +55 -2
package/dist/server/index.js +20 -63
package/dist/server/pty-handler.js +2 -0
package/dist/server/push.js +1 -32
package/dist/server/sessions.js +98 -133
package/dist/server/types.js +1 -1
package/dist/server/workspaces.js +8 -2
package/dist/server/ws.js +4 -93
package/dist/test/pr-state.test.js +69 -13
package/package.json +1 -2
package/dist/frontend/assets/index-BRH8jV0L.js +0 -47
package/dist/frontend/assets/index-w5wJhB5f.css +0 -32
package/dist/server/sdk-handler.js +0 -539

package/dist/frontend/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
   <meta name="theme-color" content="#1a1a1a" />
-  <script type="module" crossorigin src="/assets/index-BRH8jV0L.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-w5wJhB5f.css">
+  <script type="module" crossorigin src="/assets/index-ggOT9Hda.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BNLfnaOa.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/server/git.js CHANGED Viewed

@@ -168,7 +168,7 @@ async function getPrForBranch(repoPath, branch, options = {}) {
             'view',
             branch,
             '--json',
-            'number,title,url,state,headRefName,baseRefName,reviewDecision,isDraft',
+            'number,title,url,state,headRefName,baseRefName,reviewDecision,isDraft,additions,deletions,mergeable',
         ], { cwd: repoPath, timeout: 5000 }));
     }
     catch {
@@ -187,6 +187,10 @@ async function getPrForBranch(repoPath, branch, options = {}) {
             baseRefName: data.baseRefName,
             isDraft: data.isDraft,
             reviewDecision: data.reviewDecision ?? null,
+            additions: data.additions ?? 0,
+            deletions: data.deletions ?? 0,
+            mergeable: data.mergeable ?? 'UNKNOWN',
+            unresolvedCommentCount: 0,
         };
     }
     catch {
@@ -219,4 +223,53 @@ async function getCommitsAhead(repoPath, branch, baseBranch, options = {}) {
         return 0;
     }
 }
-export { listBranches, normalizeBranchNames, getActivityFeed, getCiStatus, getPrForBranch, switchBranch, getCommitsAhead, getCurrentBranch, };
+async function getUnresolvedCommentCount(repoPath, prNumber, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout: repoStdout } = await run('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], { cwd: repoPath, timeout: 5000 });
+        const nameWithOwner = repoStdout.trim();
+        if (!nameWithOwner)
+            return 0;
+        const [owner, repo] = nameWithOwner.split('/');
+        if (!owner || !repo)
+            return 0;
+        const query = `query($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100) {
+        nodes { isResolved }
+      }
+    }
+  }
+}`;
+        const { stdout } = await run('gh', [
+            'api', 'graphql',
+            '-f', `query=${query}`,
+            '-f', `owner=${owner}`,
+            '-f', `repo=${repo}`,
+            '-F', `number=${prNumber}`,
+        ], { cwd: repoPath, timeout: 10000 });
+        const result = JSON.parse(stdout);
+        const nodes = result?.data?.repository?.pullRequest?.reviewThreads?.nodes ?? [];
+        return nodes.filter((n) => !n.isResolved).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getWorkingTreeDiff(repoPath, exec = execFileAsync) {
+    try {
+        const { stdout } = await exec('git', ['diff', '--shortstat'], { cwd: repoPath, timeout: 5000 });
+        // Output like: " 3 files changed, 55 insertions(+), 12 deletions(-)"
+        const insertions = stdout.match(/(\d+) insertion/);
+        const deletions = stdout.match(/(\d+) deletion/);
+        return {
+            additions: insertions?.[1] ? parseInt(insertions[1], 10) : 0,
+            deletions: deletions?.[1] ? parseInt(deletions[1], 10) : 0,
+        };
+    }
+    catch {
+        return { additions: 0, deletions: 0 };
+    }
+}
+export { listBranches, normalizeBranchNames, getActivityFeed, getCiStatus, getPrForBranch, getUnresolvedCommentCount, switchBranch, getCommitsAhead, getCurrentBranch, getWorkingTreeDiff, };

package/dist/server/index.js CHANGED Viewed

@@ -11,7 +11,7 @@ import cookieParser from 'cookie-parser';
 import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, deleteMeta, ensureMetaDir } from './config.js';
 import * as auth from './auth.js';
 import * as sessions from './sessions.js';
-import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames, startSdkIdleSweep, stopSdkIdleSweep } from './sessions.js';
+import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache } from './sessions.js';
 import { setupWebSocket } from './ws.js';
 import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
@@ -134,12 +134,6 @@ async function main() {
         config.port = parseInt(process.env.CLAUDE_REMOTE_PORT, 10);
     if (process.env.CLAUDE_REMOTE_HOST)
         config.host = process.env.CLAUDE_REMOTE_HOST;
-    // Enable SDK debug logging if requested
-    if (process.env.CLAUDE_REMOTE_DEBUG_LOG === '1' || config.debugLog) {
-        const { enableDebugLog } = await import('./sdk-handler.js');
-        enableDebugLog(true);
-        console.log('SDK debug logging enabled → ~/.config/claude-remote-cli/debug/');
-    }
     push.ensureVapidKeys(config, CONFIG_PATH, saveConfig);
     if (!config.pinHash) {
         const pin = await promptPin('Set up a PIN for claude-remote-cli:');
@@ -216,6 +210,8 @@ async function main() {
     if (restoredCount > 0) {
         console.log(`Restored ${restoredCount} session(s) from previous update.`);
     }
+    // Populate session metadata cache in background (non-blocking)
+    populateMetaCache().catch(() => { });
     // Push notifications on session idle
     sessions.onIdleChange((sessionId, idle) => {
         if (idle) {
@@ -259,6 +255,22 @@ async function main() {
     app.get('/sessions', requireAuth, (_req, res) => {
         res.json(sessions.list());
     });
+    // GET /sessions/meta — bulk metadata for all sessions (cached)
+    app.get('/sessions/meta', requireAuth, (_req, res) => {
+        res.json(getAllSessionMeta());
+    });
+    // GET /sessions/:id/meta — individual session metadata
+    app.get('/sessions/:id/meta', requireAuth, async (req, res) => {
+        const id = req.params.id ?? '';
+        const refresh = req.query.refresh === 'true';
+        try {
+            const meta = await getSessionMeta(id, refresh);
+            res.json(meta ?? { prNumber: null, additions: 0, deletions: 0, fetchedAt: new Date().toISOString() });
+        }
+        catch {
+            res.json({ prNumber: null, additions: 0, deletions: 0, fetchedAt: new Date().toISOString() });
+        }
+    });
     // GET /branches?repo=<path> — list local and remote branches for a repo
     app.get('/branches', requireAuth, async (req, res) => {
         const repoPath = typeof req.query.repo === 'string' ? req.query.repo : undefined;
@@ -732,58 +744,6 @@ async function main() {
             res.status(404).json({ error: 'Session not found' });
         }
     });
-    // POST /sessions/:id/message — send message to SDK session
-    app.post('/sessions/:id/message', requireAuth, (req, res) => {
-        const id = req.params['id'];
-        const { text } = req.body;
-        if (!text) {
-            res.status(400).json({ error: 'text is required' });
-            return;
-        }
-        const session = sessions.get(id);
-        if (!session) {
-            res.status(404).json({ error: 'Session not found' });
-            return;
-        }
-        if (session.mode !== 'sdk') {
-            res.status(400).json({ error: 'Session is not an SDK session — use WebSocket for PTY sessions' });
-            return;
-        }
-        try {
-            sessions.write(id, text);
-            res.json({ ok: true });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to send message';
-            res.status(500).json({ error: message });
-        }
-    });
-    // POST /sessions/:id/permission — handle permission approval for SDK session
-    app.post('/sessions/:id/permission', requireAuth, (req, res) => {
-        const id = req.params['id'];
-        const { requestId, approved } = req.body;
-        if (!requestId || typeof approved !== 'boolean') {
-            res.status(400).json({ error: 'requestId and approved are required' });
-            return;
-        }
-        const session = sessions.get(id);
-        if (!session) {
-            res.status(404).json({ error: 'Session not found' });
-            return;
-        }
-        if (session.mode !== 'sdk') {
-            res.status(400).json({ error: 'Session is not an SDK session' });
-            return;
-        }
-        try {
-            sessions.handlePermission(id, requestId, approved);
-            res.json({ ok: true });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to handle permission';
-            res.status(500).json({ error: message });
-        }
-    });
     // PATCH /sessions/:id — update displayName and persist to metadata
     app.patch('/sessions/:id', requireAuth, (req, res) => {
         const { displayName } = req.body;
@@ -891,15 +851,12 @@ async function main() {
     catch {
         // tmux not installed or no sessions — ignore
     }
-    // Start SDK idle sweep
-    startSdkIdleSweep();
     function gracefulShutdown() {
         server.close();
-        stopSdkIdleSweep();
         // Serialize sessions to disk BEFORE killing them
         const configDir = path.dirname(CONFIG_PATH);
         serializeAll(configDir);
-        // Kill all active sessions (PTY + tmux + SDK)
+        // Kill all active sessions (PTY + tmux)
         for (const s of sessions.list()) {
             try {
                 sessions.kill(s.id);

package/dist/server/pty-handler.js CHANGED Viewed

@@ -4,6 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS } from './types.js';
 import { readMeta, writeMeta } from './config.js';
+import { fireSessionEnd } from './sessions.js';
 const IDLE_TIMEOUT_MS = 5000;
 const MAX_SCROLLBACK = 256 * 1024; // 256KB max
 export function generateTmuxSessionName(displayName, id) {
@@ -184,6 +185,7 @@ export function createPtySession(params, sessionsMap, idleChangeCallbacks) {
             if (configPath && worktreeName) {
                 writeMeta(configPath, { worktreePath: repoPath, displayName: session.displayName, lastActivity: session.lastActivity });
             }
+            fireSessionEnd(id, repoPath, session.branchName);
             sessionsMap.delete(id);
             const tmpDir = path.join(os.tmpdir(), 'claude-remote-cli', id);
             fs.rm(tmpDir, { recursive: true, force: true }, () => { });

package/dist/server/push.js CHANGED Viewed

@@ -40,33 +40,6 @@ export function removeSession(sessionId) {
         entry.sessionIds.delete(sessionId);
     }
 }
-export function enrichNotification(event) {
-    try {
-        switch (event.type) {
-            case 'tool_call': {
-                const action = event.toolName || 'use a tool';
-                const target = event.path || (event.toolInput && typeof event.toolInput === 'object'
-                    ? event.toolInput.file_path || event.toolInput.command || ''
-                    : '');
-                const msg = target
-                    ? `Claude wants to ${action} ${target}`
-                    : `Claude wants to ${action}`;
-                return msg.slice(0, 200);
-            }
-            case 'turn_completed':
-                return 'Claude finished';
-            case 'error': {
-                const brief = (event.text || 'unknown error').slice(0, 150);
-                return `Claude hit an error: ${brief}`;
-            }
-            default:
-                return 'Claude is waiting for your input';
-        }
-    }
-    catch {
-        return 'Claude is waiting for your input';
-    }
-}
 function truncatePayload(payload) {
     if (payload.length <= MAX_PAYLOAD_SIZE)
         return payload;
@@ -85,19 +58,15 @@ function truncatePayload(payload) {
     }
     return payload.slice(0, MAX_PAYLOAD_SIZE);
 }
-export function notifySessionIdle(sessionId, session, sdkEvent) {
+export function notifySessionIdle(sessionId, session) {
     if (!vapidPublicKey)
         return;
-    const enrichedMessage = sdkEvent ? enrichNotification(sdkEvent) : undefined;
     const payloadObj = {
         type: 'session-attention',
         sessionId,
         displayName: session.displayName,
         sessionType: session.type,
     };
-    if (enrichedMessage) {
-        payloadObj.enrichedMessage = enrichedMessage;
-    }
     const payload = truncatePayload(JSON.stringify(payloadObj));
     for (const [endpoint, entry] of subscriptions) {
         if (!entry.sessionIds.has(sessionId))

package/dist/server/sessions.js CHANGED Viewed

@@ -5,41 +5,29 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS } from './types.js';
 import { createPtySession } from './pty-handler.js';
-import { createSdkSession, killSdkSession, sendMessage as sdkSendMessage, handlePermission as sdkHandlePermission, serializeSdkSession, restoreSdkSession } from './sdk-handler.js';
+import { getPrForBranch, getWorkingTreeDiff } from './git.js';
 const execFileAsync = promisify(execFile);
 const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
-const SDK_IDLE_CHECK_INTERVAL_MS = 60 * 1000; // 60 seconds
-const SDK_MAX_IDLE_MS = 30 * 60 * 1000; // 30 minutes
-const SDK_MAX_IDLE_SESSIONS = 5;
 // In-memory registry: id -> Session
 const sessions = new Map();
+// Session metadata cache: session ID or worktree path -> SessionMeta
+const metaCache = new Map();
 let terminalCounter = 0;
 const idleChangeCallbacks = [];
 function onIdleChange(cb) {
     idleChangeCallbacks.push(cb);
 }
+const sessionEndCallbacks = [];
+function onSessionEnd(cb) {
+    sessionEndCallbacks.push(cb);
+}
+function fireSessionEnd(sessionId, repoPath, branchName) {
+    for (const cb of sessionEndCallbacks)
+        cb(sessionId, repoPath, branchName);
+}
 function create({ id: providedId, type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux, tmuxSessionName: paramTmuxSessionName, initialScrollback, restored: paramRestored, needsBranchRename: paramNeedsBranchRename, branchRenamePrompt: paramBranchRenamePrompt }) {
     const id = providedId || crypto.randomBytes(8).toString('hex');
-    // Dispatch: if agent is claude, no custom command, try SDK first
-    if (agent === 'claude' && !command) {
-        const sdkResult = createSdkSession({
-            id,
-            type,
-            agent,
-            repoName,
-            repoPath,
-            cwd,
-            root,
-            worktreeName,
-            branchName,
-            displayName,
-        }, sessions, idleChangeCallbacks);
-        if (!('fallback' in sdkResult)) {
-            return { ...sdkResult.result, pid: undefined, needsBranchRename: false };
-        }
-        // SDK init failed — fall through to PTY
-    }
-    // PTY path: codex, terminal, custom command, or SDK fallback
+    // PTY path
     const ptyParams = {
         id,
         type,
@@ -91,10 +79,10 @@ function list() {
         idle: s.idle,
         cwd: s.cwd,
         customCommand: s.customCommand,
-        useTmux: s.mode === 'pty' ? s.useTmux : false,
-        tmuxSessionName: s.mode === 'pty' ? s.tmuxSessionName : '',
+        useTmux: s.useTmux,
+        tmuxSessionName: s.tmuxSessionName,
         status: s.status,
-        needsBranchRename: s.mode === 'pty' ? !!s.needsBranchRename : false,
+        needsBranchRename: !!s.needsBranchRename,
     }))
         .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
 }
@@ -110,25 +98,21 @@ function kill(id) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    if (session.mode === 'pty') {
-        try {
-            session.pty.kill('SIGTERM');
-        }
-        catch {
-            // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
-        }
-        if (session.tmuxSessionName) {
-            execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
-        }
+    try {
+        session.pty.kill('SIGTERM');
     }
-    else if (session.mode === 'sdk') {
-        killSdkSession(id);
+    catch {
+        // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
     }
+    if (session.tmuxSessionName) {
+        execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+    }
+    fireSessionEnd(id, session.repoPath, session.branchName);
     sessions.delete(id);
 }
 function killAllTmuxSessions() {
     for (const session of sessions.values()) {
-        if (session.mode === 'pty' && session.tmuxSessionName) {
+        if (session.tmuxSessionName) {
             execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
         }
     }
@@ -138,25 +122,14 @@ function resize(id, cols, rows) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    if (session.mode === 'pty') {
-        session.pty.resize(cols, rows);
-    }
-    // SDK sessions don't support resize (no PTY)
+    session.pty.resize(cols, rows);
 }
 function write(id, data) {
     const session = sessions.get(id);
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    if (session.mode === 'pty') {
-        session.pty.write(data);
-    }
-    else if (session.mode === 'sdk') {
-        sdkSendMessage(id, data);
-    }
-}
-function handlePermission(id, requestId, approved) {
-    sdkHandlePermission(id, requestId, approved);
+    session.pty.write(data);
 }
 function findRepoSession(repoPath) {
     return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
@@ -168,39 +141,32 @@ function serializeAll(configDir) {
     const scrollbackDirPath = path.join(configDir, 'scrollback');
     fs.mkdirSync(scrollbackDirPath, { recursive: true });
     const serializedPty = [];
-    const serializedSdk = [];
     for (const session of sessions.values()) {
-        if (session.mode === 'pty') {
-            // Write scrollback to disk
-            const scrollbackPath = path.join(scrollbackDirPath, session.id + '.buf');
-            fs.writeFileSync(scrollbackPath, session.scrollback.join(''), 'utf-8');
-            serializedPty.push({
-                id: session.id,
-                type: session.type,
-                agent: session.agent,
-                root: session.root,
-                repoName: session.repoName,
-                repoPath: session.repoPath,
-                worktreeName: session.worktreeName,
-                branchName: session.branchName,
-                displayName: session.displayName,
-                createdAt: session.createdAt,
-                lastActivity: session.lastActivity,
-                useTmux: session.useTmux,
-                tmuxSessionName: session.tmuxSessionName,
-                customCommand: session.customCommand,
-                cwd: session.cwd,
-            });
-        }
-        else if (session.mode === 'sdk') {
-            serializedSdk.push(serializeSdkSession(session));
-        }
+        // Write scrollback to disk
+        const scrollbackPath = path.join(scrollbackDirPath, session.id + '.buf');
+        fs.writeFileSync(scrollbackPath, session.scrollback.join(''), 'utf-8');
+        serializedPty.push({
+            id: session.id,
+            type: session.type,
+            agent: session.agent,
+            root: session.root,
+            repoName: session.repoName,
+            repoPath: session.repoPath,
+            worktreeName: session.worktreeName,
+            branchName: session.branchName,
+            displayName: session.displayName,
+            createdAt: session.createdAt,
+            lastActivity: session.lastActivity,
+            useTmux: session.useTmux,
+            tmuxSessionName: session.tmuxSessionName,
+            customCommand: session.customCommand,
+            cwd: session.cwd,
+        });
     }
     const pending = {
         version: 1,
         timestamp: new Date().toISOString(),
         sessions: serializedPty,
-        sdkSessions: serializedSdk.length > 0 ? serializedSdk : undefined,
     };
     fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending, null, 2), 'utf-8');
 }
@@ -300,18 +266,6 @@ async function restoreFromDisk(configDir) {
         }
         catch { /* ignore */ }
     }
-    // Restore SDK sessions (as disconnected — they can't resume a live process)
-    if (pending.sdkSessions) {
-        for (const sdkData of pending.sdkSessions) {
-            try {
-                restoreSdkSession(sdkData, sessions);
-                restored++;
-            }
-            catch {
-                console.error(`Failed to restore SDK session ${sdkData.id} (${sdkData.displayName})`);
-            }
-        }
-    }
     // Clean up
     try {
         fs.unlinkSync(pendingPath);
@@ -327,55 +281,66 @@ async function restoreFromDisk(configDir) {
 function activeTmuxSessionNames() {
     const names = new Set();
     for (const session of sessions.values()) {
-        if (session.mode === 'pty' && session.tmuxSessionName)
+        if (session.tmuxSessionName)
             names.add(session.tmuxSessionName);
     }
     return names;
 }
-// SDK idle sweep: check every 60s, terminate SDK sessions idle > 30min, max 5 idle
-let sdkIdleSweepTimer = null;
-function startSdkIdleSweep() {
-    if (sdkIdleSweepTimer)
-        return;
-    sdkIdleSweepTimer = setInterval(() => {
-        const now = Date.now();
-        const sdkSessions = [];
-        for (const session of sessions.values()) {
-            if (session.mode === 'sdk') {
-                sdkSessions.push(session);
-            }
-        }
-        // Terminate sessions idle > 30 minutes
-        for (const session of sdkSessions) {
-            const lastActivity = new Date(session.lastActivity).getTime();
-            if (session.idle && (now - lastActivity) > SDK_MAX_IDLE_MS) {
-                console.log(`SDK idle sweep: terminating session ${session.id} (${session.displayName}) — idle for ${Math.round((now - lastActivity) / 60000)}min`);
-                try {
-                    kill(session.id);
-                }
-                catch { /* already dead */ }
-            }
-        }
-        // LRU eviction: if more than 5 idle SDK sessions remain, evict oldest
-        const idleSdkSessions = Array.from(sessions.values())
-            .filter((s) => s.mode === 'sdk' && s.idle)
-            .sort((a, b) => a.lastActivity.localeCompare(b.lastActivity));
-        while (idleSdkSessions.length > SDK_MAX_IDLE_SESSIONS) {
-            const oldest = idleSdkSessions.shift();
-            console.log(`SDK idle sweep: evicting session ${oldest.id} (${oldest.displayName}) — LRU`);
-            try {
-                kill(oldest.id);
+async function fetchMetaForSession(session) {
+    const repoPath = session.repoPath;
+    const branch = session.branchName;
+    let prNumber = null;
+    let additions = 0;
+    let deletions = 0;
+    if (branch) {
+        try {
+            const pr = await getPrForBranch(repoPath, branch);
+            if (pr) {
+                prNumber = pr.number;
+                additions = pr.additions;
+                deletions = pr.deletions;
             }
-            catch { /* already dead */ }
         }
-    }, SDK_IDLE_CHECK_INTERVAL_MS);
+        catch { /* gh CLI unavailable */ }
+    }
+    // Fallback to working tree diff if no PR data
+    if (additions === 0 && deletions === 0) {
+        const diff = await getWorkingTreeDiff(repoPath);
+        additions = diff.additions;
+        deletions = diff.deletions;
+    }
+    return { prNumber, additions, deletions, fetchedAt: new Date().toISOString() };
 }
-function stopSdkIdleSweep() {
-    if (sdkIdleSweepTimer) {
-        clearInterval(sdkIdleSweepTimer);
-        sdkIdleSweepTimer = null;
+async function getSessionMeta(id, refresh = false) {
+    if (!refresh && metaCache.has(id))
+        return metaCache.get(id);
+    const session = sessions.get(id);
+    if (!session)
+        return metaCache.get(id) ?? null;
+    const summary = list().find(s => s.id === id);
+    if (!summary)
+        return null;
+    const meta = await fetchMetaForSession(summary);
+    metaCache.set(id, meta);
+    return meta;
+}
+function getAllSessionMeta() {
+    const result = {};
+    for (const [key, meta] of metaCache) {
+        result[key] = meta;
     }
+    return result;
+}
+// Populate cache for all active sessions (called on startup or refresh)
+async function populateMetaCache() {
+    const allSessions = list();
+    await Promise.allSettled(allSessions.map(async (s) => {
+        if (!metaCache.has(s.id)) {
+            const meta = await fetchMetaForSession(s);
+            metaCache.set(s.id, meta);
+        }
+    }));
 }
 // Re-export pty-handler utilities for backward compatibility
 export { generateTmuxSessionName, resolveTmuxSpawn } from './pty-handler.js';
-export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, handlePermission, onIdleChange, findRepoSession, nextTerminalName, serializeAll, restoreFromDisk, activeTmuxSessionNames, startSdkIdleSweep, stopSdkIdleSweep, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };
+export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, onSessionEnd, fireSessionEnd, findRepoSession, nextTerminalName, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };

package/dist/server/types.js CHANGED Viewed

@@ -1,4 +1,4 @@
-// Agent command records (shared by PTY and SDK handlers)
+// Agent command records
 export const AGENT_COMMANDS = {
     claude: 'claude',
     codex: 'codex',

package/dist/server/workspaces.js CHANGED Viewed

@@ -5,7 +5,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { Router } from 'express';
 import { loadConfig, saveConfig, getWorkspaceSettings, setWorkspaceSettings } from './config.js';
-import { listBranches, getActivityFeed, getCiStatus, getPrForBranch, switchBranch, getCurrentBranch } from './git.js';
+import { listBranches, getActivityFeed, getCiStatus, getPrForBranch, getUnresolvedCommentCount, switchBranch, getCurrentBranch } from './git.js';
 import { MOUNTAIN_NAMES } from './types.js';
 const execFileAsync = promisify(execFile);
 const BROWSE_DENYLIST = new Set([
@@ -348,7 +348,13 @@ export function createWorkspaceRouter(deps) {
         try {
             const pr = await getPrForBranch(workspacePath, branch);
             if (pr) {
-                res.json(pr);
+                if (pr.state === 'OPEN') {
+                    const unresolvedCommentCount = await getUnresolvedCommentCount(workspacePath, pr.number);
+                    res.json({ ...pr, unresolvedCommentCount });
+                }
+                else {
+                    res.json({ ...pr, unresolvedCommentCount: 0 });
+                }
             }
             else {
                 res.status(404).json({ error: 'No PR found for branch' });