claude-remote-cli 3.0.2 → 3.0.4

package/dist/server/index.js

@@ -11,16 +11,27 @@ 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 } 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';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 import { listBranches } from './git.js';
 import * as push from './push.js';
+import { createWorkspaceRouter } from './workspaces.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
+// ── Signal protection ────────────────────────────────────────────────────
+// Ignore SIGPIPE: piped bash commands (e.g. `cmd | grep | tail`) generate
+// SIGPIPE when the reading end of the pipe closes before the writer finishes.
+// node-pty's native module can propagate these to PTY sessions, causing
+// unexpected "session exited" in the browser. Ignoring SIGPIPE at the server
+// level prevents this cascade.
+process.on('SIGPIPE', () => { });
+// Ignore SIGHUP: if the controlling terminal disconnects (e.g. SSH drops),
+// keep the server and all PTY sessions alive.
+process.on('SIGHUP', () => { });
 // When run via CLI bin, config lives in ~/.config/claude-remote-cli/
 // When run directly (development), fall back to local config.json
 const CONFIG_PATH = process.env.CLAUDE_REMOTE_CONFIG || path.join(__dirname, '..', '..', 'config.json');
@@ -90,40 +101,6 @@ function promptPin(question) {
         });
     });
 }
-function scanReposInRoot(rootDir) {
-    const repos = [];
-    let entries;
-    try {
-        entries = fs.readdirSync(rootDir, { withFileTypes: true });
-    }
-    catch (_) {
-        return repos;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.'))
-            continue;
-        const fullPath = path.join(rootDir, entry.name);
-        const dotGit = path.join(fullPath, '.git');
-        try {
-            // Only count directories with a .git *directory* as repos.
-            // Worktrees and submodules have a .git *file* and should be skipped.
-            if (fs.statSync(dotGit).isDirectory()) {
-                repos.push({ name: entry.name, path: fullPath, root: rootDir });
-            }
-        }
-        catch (_) {
-            // .git doesn't exist — not a repo
-        }
-    }
-    return repos;
-}
-function scanAllRepos(rootDirs) {
-    const repos = [];
-    for (const rootDir of rootDirs) {
-        repos.push(...scanReposInRoot(rootDir));
-    }
-    return repos;
-}
 function ensureGitignore(repoPath, entry) {
     const gitignorePath = path.join(repoPath, '.gitignore');
     try {
@@ -156,12 +133,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:');
@@ -226,9 +197,12 @@ async function main() {
         });
     }
     const watcher = new WorktreeWatcher();
-    watcher.rebuild(config.rootDirs || []);
+    watcher.rebuild(config.workspaces || []);
     const server = http.createServer(app);
     const { broadcastEvent } = setupWebSocket(server, authenticatedTokens, watcher);
+    // Mount workspace router
+    const workspaceRouter = createWorkspaceRouter({ configPath: CONFIG_PATH });
+    app.use('/workspaces', requireAuth, workspaceRouter);
     // Restore sessions from a previous update restart
     const configDir = path.dirname(CONFIG_PATH);
     const restoredCount = await restoreFromDisk(configDir);
@@ -278,19 +252,6 @@ async function main() {
     app.get('/sessions', requireAuth, (_req, res) => {
         res.json(sessions.list());
     });
-    // GET /repos — scan root dirs for repos
-    app.get('/repos', requireAuth, (_req, res) => {
-        const repos = scanAllRepos(config.rootDirs || []);
-        // Also include legacy manually-added repos
-        if (config.repos) {
-            for (const repo of config.repos) {
-                if (!repos.some((r) => r.path === repo.path)) {
-                    repos.push(repo);
-                }
-            }
-        }
-        res.json(repos);
-    });
     // 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;
@@ -301,134 +262,6 @@ async function main() {
         }
         res.json(await listBranches(repoPath, { refresh }));
     });
-    // GET /git-status?repo=<path>&branch=<name>
-    app.get('/git-status', requireAuth, async (req, res) => {
-        const repoPath = typeof req.query.repo === 'string' ? req.query.repo : undefined;
-        const branch = typeof req.query.branch === 'string' ? req.query.branch : undefined;
-        if (!repoPath || !branch) {
-            res.status(400).json({ error: 'repo and branch query parameters are required' });
-            return;
-        }
-        let prState = null;
-        let additions = 0;
-        let deletions = 0;
-        // Try gh CLI for PR status
-        try {
-            const { stdout } = await execFileAsync('gh', [
-                'pr', 'view', branch,
-                '--json', 'state,additions,deletions',
-            ], { cwd: repoPath });
-            const data = JSON.parse(stdout);
-            if (data.state)
-                prState = data.state.toLowerCase();
-            if (typeof data.additions === 'number')
-                additions = data.additions;
-            if (typeof data.deletions === 'number')
-                deletions = data.deletions;
-        }
-        catch {
-            // No PR or gh not available — fall back to git diff against default branch
-            try {
-                // Detect default branch (main, master, etc.)
-                let baseBranch = 'main';
-                try {
-                    const { stdout: headRef } = await execFileAsync('git', [
-                        'symbolic-ref', 'refs/remotes/origin/HEAD', '--short',
-                    ], { cwd: repoPath });
-                    baseBranch = headRef.trim().replace(/^origin\//, '');
-                }
-                catch { /* use main as fallback */ }
-                const { stdout } = await execFileAsync('git', [
-                    'diff', '--shortstat', baseBranch + '...' + branch,
-                ], { cwd: repoPath });
-                const addMatch = stdout.match(/(\d+) insertion/);
-                const delMatch = stdout.match(/(\d+) deletion/);
-                if (addMatch)
-                    additions = parseInt(addMatch[1], 10);
-                if (delMatch)
-                    deletions = parseInt(delMatch[1], 10);
-            }
-            catch { /* no diff data */ }
-        }
-        res.json({ prState, additions, deletions });
-    });
-    // GET /pull-requests?repo=<path>
-    app.get('/pull-requests', requireAuth, async (req, res) => {
-        const repoPath = typeof req.query.repo === 'string' ? req.query.repo : undefined;
-        if (!repoPath) {
-            res.status(400).json({ prs: [], error: 'repo query parameter is required' });
-            return;
-        }
-        const fields = 'number,title,url,headRefName,state,author,updatedAt,additions,deletions,reviewDecision';
-        // Get current GitHub user
-        let currentUser = '';
-        try {
-            const { stdout: whoami } = await execFileAsync('gh', ['api', 'user', '--jq', '.login'], { cwd: repoPath });
-            currentUser = whoami.trim();
-        }
-        catch {
-            const response = { prs: [], error: 'gh_not_authenticated' };
-            res.json(response);
-            return;
-        }
-        // Fetch authored PRs
-        const authored = [];
-        try {
-            const { stdout } = await execFileAsync('gh', [
-                'pr', 'list', '--author', currentUser, '--state', 'open', '--limit', '30',
-                '--json', fields,
-            ], { cwd: repoPath });
-            const raw = JSON.parse(stdout);
-            for (const pr of raw) {
-                authored.push({
-                    number: pr.number,
-                    title: pr.title,
-                    url: pr.url,
-                    headRefName: pr.headRefName,
-                    state: pr.state,
-                    author: pr.author?.login ?? currentUser,
-                    role: 'author',
-                    updatedAt: pr.updatedAt,
-                    additions: pr.additions ?? 0,
-                    deletions: pr.deletions ?? 0,
-                    reviewDecision: pr.reviewDecision ?? null,
-                });
-            }
-        }
-        catch { /* no authored PRs or gh error */ }
-        // Fetch review-requested PRs
-        const reviewing = [];
-        try {
-            const { stdout } = await execFileAsync('gh', [
-                'pr', 'list', '--search', `review-requested:${currentUser}`, '--state', 'open', '--limit', '30',
-                '--json', fields,
-            ], { cwd: repoPath });
-            const raw = JSON.parse(stdout);
-            for (const pr of raw) {
-                reviewing.push({
-                    number: pr.number,
-                    title: pr.title,
-                    url: pr.url,
-                    headRefName: pr.headRefName,
-                    state: pr.state,
-                    author: pr.author?.login ?? '',
-                    role: 'reviewer',
-                    updatedAt: pr.updatedAt,
-                    additions: pr.additions ?? 0,
-                    deletions: pr.deletions ?? 0,
-                    reviewDecision: pr.reviewDecision ?? null,
-                });
-            }
-        }
-        catch { /* no review-requested PRs or gh error */ }
-        // Deduplicate: if a PR appears in both (user is author AND reviewer), keep as 'author'
-        const seen = new Set(authored.map(pr => pr.number));
-        const combined = [...authored, ...reviewing.filter(pr => !seen.has(pr.number))];
-        // Sort by updatedAt descending
-        combined.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-        const response = { prs: combined };
-        res.json(response);
-    });
     // GET /worktrees?repo=<path> — list worktrees; omit repo to scan all repos in all rootDirs
     app.get('/worktrees', requireAuth, async (req, res) => {
         const repoParam = typeof req.query.repo === 'string' ? req.query.repo : undefined;
@@ -440,7 +273,30 @@ async function main() {
             reposToScan = [{ path: repoParam, name: repoParam.split('/').filter(Boolean).pop() || '', root }];
         }
         else {
-            reposToScan = scanAllRepos(roots);
+            reposToScan = [];
+            for (const rootDir of roots) {
+                let entries;
+                try {
+                    entries = fs.readdirSync(rootDir, { withFileTypes: true });
+                }
+                catch (_) {
+                    continue;
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = path.join(rootDir, entry.name);
+                    const dotGit = path.join(fullPath, '.git');
+                    try {
+                        if (fs.statSync(dotGit).isDirectory()) {
+                            reposToScan.push({ name: entry.name, path: fullPath, root: rootDir });
+                        }
+                    }
+                    catch (_) {
+                        // .git doesn't exist — not a repo
+                    }
+                }
+            }
         }
         for (const repo of reposToScan) {
             // Use git worktree list to discover all worktrees (including those at arbitrary paths)
@@ -502,42 +358,6 @@ async function main() {
         });
         res.json(unique);
     });
-    // GET /roots — list root directories
-    app.get('/roots', requireAuth, (_req, res) => {
-        res.json(config.rootDirs || []);
-    });
-    // POST /roots — add a root directory
-    app.post('/roots', requireAuth, (req, res) => {
-        const { path: rootPath } = req.body;
-        if (!rootPath) {
-            res.status(400).json({ error: 'path is required' });
-            return;
-        }
-        if (!config.rootDirs)
-            config.rootDirs = [];
-        if (config.rootDirs.includes(rootPath)) {
-            res.status(409).json({ error: 'Root already exists' });
-            return;
-        }
-        config.rootDirs.push(rootPath);
-        saveConfig(CONFIG_PATH, config);
-        watcher.rebuild(config.rootDirs);
-        broadcastEvent('worktrees-changed');
-        res.status(201).json(config.rootDirs);
-    });
-    // DELETE /roots — remove a root directory
-    app.delete('/roots', requireAuth, (req, res) => {
-        const { path: rootPath } = req.body;
-        if (!rootPath || !config.rootDirs) {
-            res.status(400).json({ error: 'path is required' });
-            return;
-        }
-        config.rootDirs = config.rootDirs.filter((r) => r !== rootPath);
-        saveConfig(CONFIG_PATH, config);
-        watcher.rebuild(config.rootDirs);
-        broadcastEvent('worktrees-changed');
-        res.json(config.rootDirs);
-    });
     // GET /config/defaultAgent — get default coding agent
     app.get('/config/defaultAgent', requireAuth, (_req, res) => {
         res.json({ defaultAgent: config.defaultAgent || 'claude' });
@@ -612,13 +432,7 @@ async function main() {
                 return;
             }
         }
-        // Check no active session is using this worktree
-        const activeSessions = sessions.list();
-        const conflict = activeSessions.find(function (s) { return s.repoPath === worktreePath; });
-        if (conflict) {
-            res.status(409).json({ error: 'Close the active session first' });
-            return;
-        }
+        // Multiple sessions per worktree allowed (multi-tab support)
         // Derive branch name from metadata or worktree directory name
         const meta = readMeta(CONFIG_PATH, worktreePath);
         const branchName = (meta && meta.branchName) || worktreePath.split('/').pop() || '';
@@ -662,7 +476,7 @@ async function main() {
     });
     // POST /sessions
     app.post('/sessions', requireAuth, async (req, res) => {
-        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent, useTmux } = req.body;
+        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent, useTmux, needsBranchRename, branchRenamePrompt } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
@@ -683,8 +497,11 @@ async function main() {
         let sessionRepoPath;
         let resolvedBranch = '';
         if (worktreePath) {
-            // Resume existing worktree
-            args = [...AGENT_CONTINUE_ARGS[resolvedAgent], ...baseArgs];
+            // Only use --continue if:
+            // 1. Not a brand-new worktree (needsBranchRename flag)
+            // 2. A prior Claude session exists in this directory (.claude/ dir present)
+            const hasPriorSession = !needsBranchRename && fs.existsSync(path.join(worktreePath, '.claude'));
+            args = hasPriorSession ? [...AGENT_CONTINUE_ARGS[resolvedAgent], ...baseArgs] : [...baseArgs];
             cwd = worktreePath;
             sessionRepoPath = worktreePath;
             worktreeName = worktreePath.split('/').pop() || '';
@@ -816,6 +633,8 @@ async function main() {
             args,
             configPath: CONFIG_PATH,
             useTmux: useTmux ?? config.launchInTmux,
+            needsBranchRename: needsBranchRename ?? false,
+            branchRenamePrompt: branchRenamePrompt ?? '',
         });
         if (!worktreePath) {
             writeMeta(CONFIG_PATH, {
@@ -835,12 +654,7 @@ async function main() {
             return;
         }
         const resolvedAgent = agent || config.defaultAgent || 'claude';
-        // One repo session at a time
-        const existing = sessions.findRepoSession(repoPath);
-        if (existing) {
-            res.status(409).json({ error: 'A session already exists for this repo', sessionId: existing.id });
-            return;
-        }
+        // Multiple sessions per repo allowed (multi-tab support)
         const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
         const baseArgs = [
             ...(config.claudeArgs || []),
@@ -890,58 +704,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;
@@ -1049,15 +811,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/push.js

@@ -1,7 +1,6 @@
 import webpush from 'web-push';
 let vapidPublicKey = null;
 const subscriptions = new Map();
-const MAX_PAYLOAD_SIZE = 4 * 1024; // 4KB
 export function ensureVapidKeys(config, configPath, save) {
     if (config.vapidPublicKey && config.vapidPrivateKey) {
         vapidPublicKey = config.vapidPublicKey;
@@ -40,65 +39,15 @@ 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;
-    // Try to parse, truncate text fields, and re-serialize
-    try {
-        const obj = JSON.parse(payload);
-        if (typeof obj.enrichedMessage === 'string' && obj.enrichedMessage.length > 100) {
-            obj.enrichedMessage = obj.enrichedMessage.slice(0, 100) + '...';
-        }
-        const truncated = JSON.stringify(obj);
-        if (truncated.length <= MAX_PAYLOAD_SIZE)
-            return truncated;
-    }
-    catch {
-        // fall through
-    }
-    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 = {
+    const payload = JSON.stringify({
         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))
             continue;