claude-remote-cli 3.0.3 → 3.0.5

package/dist/server/workspaces.js

@@ -0,0 +1,448 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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 { MOUNTAIN_NAMES } from './types.js';
+const execFileAsync = promisify(execFile);
+// ---------------------------------------------------------------------------
+// Exported helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolves and validates a raw workspace path string.
+ * Throws with a human-readable message if the path is invalid.
+ */
+export async function validateWorkspacePath(rawPath) {
+    if (!rawPath || typeof rawPath !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    const resolved = path.resolve(rawPath);
+    let stat;
+    try {
+        stat = await fs.promises.stat(resolved);
+    }
+    catch {
+        throw new Error(`Path does not exist: ${resolved}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`Path is not a directory: ${resolved}`);
+    }
+    return resolved;
+}
+/**
+ * Detects whether a directory is the root of a git repository and, if so,
+ * what the default branch name is.
+ */
+export async function detectGitRepo(dirPath, execAsync = execFileAsync) {
+    try {
+        await execAsync('git', ['rev-parse', '--git-dir'], { cwd: dirPath });
+    }
+    catch {
+        return { isGitRepo: false, defaultBranch: null };
+    }
+    // Attempt to determine the default branch from remote HEAD
+    let defaultBranch = null;
+    try {
+        const { stdout } = await execAsync('git', ['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], { cwd: dirPath });
+        const trimmed = stdout.trim();
+        // "origin/main" → "main"
+        defaultBranch = trimmed.replace(/^origin\//, '') || null;
+    }
+    catch {
+        // Fall back to checking local HEAD
+        try {
+            const { stdout } = await execAsync('git', ['symbolic-ref', '--short', 'HEAD'], { cwd: dirPath });
+            defaultBranch = stdout.trim() || null;
+        }
+        catch {
+            // Cannot determine default branch
+        }
+    }
+    return { isGitRepo: true, defaultBranch };
+}
+// ---------------------------------------------------------------------------
+// Router factory
+// ---------------------------------------------------------------------------
+/**
+ * Creates and returns an Express Router that handles all /workspaces routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/workspaces', requireAuth, createWorkspaceRouter({ configPath }));
+ */
+export function createWorkspaceRouter(deps) {
+    const { configPath } = deps;
+    const exec = deps.execAsync ?? execFileAsync;
+    const router = Router();
+    // Helper: reload config on every request so concurrent changes are reflected
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    // -------------------------------------------------------------------------
+    // GET /workspaces — list all workspaces with git info
+    // -------------------------------------------------------------------------
+    router.get('/', async (_req, res) => {
+        const config = getConfig();
+        const workspacePaths = config.workspaces ?? [];
+        const results = await Promise.all(workspacePaths.map(async (p) => {
+            const name = path.basename(p);
+            const { isGitRepo, defaultBranch } = await detectGitRepo(p, exec);
+            return { path: p, name, isGitRepo, defaultBranch };
+        }));
+        res.json({ workspaces: results });
+    });
+    // -------------------------------------------------------------------------
+    // POST /workspaces — add a workspace
+    // -------------------------------------------------------------------------
+    router.post('/', async (req, res) => {
+        const body = req.body;
+        const rawPath = body.path;
+        if (typeof rawPath !== 'string' || !rawPath) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        let resolved;
+        try {
+            resolved = await validateWorkspacePath(rawPath);
+        }
+        catch (err) {
+            res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            return;
+        }
+        const config = getConfig();
+        const workspaces = config.workspaces ?? [];
+        if (workspaces.includes(resolved)) {
+            res.status(409).json({ error: 'Workspace already exists' });
+            return;
+        }
+        const { isGitRepo, defaultBranch } = await detectGitRepo(resolved, exec);
+        config.workspaces = [...workspaces, resolved];
+        // Store detected default branch in per-workspace settings
+        if (isGitRepo && defaultBranch) {
+            if (!config.workspaceSettings)
+                config.workspaceSettings = {};
+            config.workspaceSettings[resolved] = {
+                ...config.workspaceSettings[resolved],
+                defaultBranch,
+            };
+        }
+        saveConfig(configPath, config);
+        const workspace = {
+            path: resolved,
+            name: path.basename(resolved),
+            isGitRepo,
+            defaultBranch,
+        };
+        res.status(201).json(workspace);
+    });
+    // -------------------------------------------------------------------------
+    // DELETE /workspaces — remove a workspace
+    // -------------------------------------------------------------------------
+    router.delete('/', async (req, res) => {
+        const body = req.body;
+        const rawPath = body.path;
+        if (typeof rawPath !== 'string' || !rawPath) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        const resolved = path.resolve(rawPath);
+        const config = getConfig();
+        const workspaces = config.workspaces ?? [];
+        const idx = workspaces.indexOf(resolved);
+        if (idx === -1) {
+            res.status(404).json({ error: 'Workspace not found' });
+            return;
+        }
+        config.workspaces = workspaces.filter((p) => p !== resolved);
+        saveConfig(configPath, config);
+        res.json({ removed: resolved });
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/dashboard — aggregated PR + activity data for a workspace
+    // -------------------------------------------------------------------------
+    router.get('/dashboard', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const fields = 'number,title,url,headRefName,state,author,updatedAt,additions,deletions,reviewDecision,mergeable,mergeStateStatus';
+        // Get current GitHub user
+        let currentUser = '';
+        try {
+            const { stdout: whoami } = await exec('gh', ['api', 'user', '--jq', '.login'], { cwd: workspacePath });
+            currentUser = whoami.trim();
+        }
+        catch {
+            const response = { prs: [], error: 'gh_not_authenticated' };
+            res.json({ pullRequests: response, branches: [] });
+            return;
+        }
+        // Helper to map raw gh JSON to PullRequest
+        function mapRawPr(raw, role, fallbackAuthor) {
+            return {
+                number: raw.number,
+                title: raw.title,
+                url: raw.url,
+                headRefName: raw.headRefName,
+                state: raw.state,
+                author: raw.author?.login ?? fallbackAuthor,
+                role,
+                updatedAt: raw.updatedAt,
+                additions: raw.additions ?? 0,
+                deletions: raw.deletions ?? 0,
+                reviewDecision: raw.reviewDecision ?? null,
+                mergeable: raw.mergeable ?? null,
+            };
+        }
+        // Fetch authored + review-requested PRs in parallel
+        const [authored, reviewing] = await Promise.all([
+            (async () => {
+                try {
+                    const { stdout } = await exec('gh', ['pr', 'list', '--author', currentUser, '--state', 'open', '--limit', '30', '--json', fields], { cwd: workspacePath });
+                    return JSON.parse(stdout).map(pr => mapRawPr(pr, 'author', currentUser));
+                }
+                catch {
+                    return [];
+                }
+            })(),
+            (async () => {
+                try {
+                    const { stdout } = await exec('gh', ['pr', 'list', '--search', `review-requested:${currentUser}`, '--state', 'open', '--limit', '30', '--json', fields], { cwd: workspacePath });
+                    return JSON.parse(stdout).map(pr => mapRawPr(pr, 'reviewer', ''));
+                }
+                catch {
+                    return [];
+                }
+            })(),
+        ]);
+        // Deduplicate: if a PR appears in both, 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 pullRequests = { prs: combined };
+        // Fetch branches for the workspace
+        let branches = [];
+        try {
+            branches = await listBranches(workspacePath);
+        }
+        catch { /* not a git repo or git unavailable */ }
+        // Fetch recent activity
+        let activity = [];
+        try {
+            activity = await getActivityFeed(workspacePath);
+        }
+        catch { /* git log unavailable */ }
+        res.json({
+            pullRequests,
+            branches,
+            activity,
+        });
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/settings — per-workspace settings
+    // -------------------------------------------------------------------------
+    router.get('/settings', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const config = getConfig();
+        const resolved = path.resolve(workspacePath);
+        const settings = config.workspaceSettings?.[resolved] ?? {};
+        res.json(settings);
+    });
+    // -------------------------------------------------------------------------
+    // PATCH /workspaces/settings — update per-workspace settings
+    // -------------------------------------------------------------------------
+    router.patch('/settings', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const resolved = path.resolve(workspacePath);
+        const updates = req.body;
+        const config = getConfig();
+        const current = config.workspaceSettings?.[resolved] ?? {};
+        const merged = { ...current, ...updates };
+        config.workspaceSettings = { ...config.workspaceSettings, [resolved]: merged };
+        saveConfig(configPath, config);
+        res.json(merged);
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/pr — PR info for a specific branch
+    // -------------------------------------------------------------------------
+    router.get('/pr', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        const branch = typeof req.query.branch === 'string' ? req.query.branch : undefined;
+        if (!workspacePath || !branch) {
+            res.status(400).json({ error: 'path and branch query parameters are required' });
+            return;
+        }
+        try {
+            const pr = await getPrForBranch(workspacePath, branch);
+            if (pr) {
+                res.json(pr);
+            }
+            else {
+                res.status(404).json({ error: 'No PR found for branch' });
+            }
+        }
+        catch {
+            res.status(404).json({ error: 'No PR found for branch' });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/ci-status — CI check results for a workspace + branch
+    // -------------------------------------------------------------------------
+    router.get('/ci-status', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        const branch = typeof req.query.branch === 'string' ? req.query.branch : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        try {
+            const status = await getCiStatus(workspacePath, branch ?? 'HEAD');
+            res.json(status);
+        }
+        catch {
+            res.json({ total: 0, passing: 0, failing: 0, pending: 0 });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // POST /workspaces/branch — switch branch for a workspace
+    // -------------------------------------------------------------------------
+    router.post('/branch', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const body = req.body;
+        const branch = body.branch;
+        if (typeof branch !== 'string' || !branch) {
+            res.status(400).json({ error: 'branch is required in request body' });
+            return;
+        }
+        const result = await switchBranch(workspacePath, branch);
+        if (result.success) {
+            res.json({ path: workspacePath, branch });
+        }
+        else {
+            res.status(400).json({ error: result.error ?? `Failed to switch to branch: ${branch}` });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // POST /workspaces/worktree — create a new worktree with the next mountain name
+    // -------------------------------------------------------------------------
+    router.post('/worktree', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const resolved = path.resolve(workspacePath);
+        const config = getConfig();
+        const settings = getWorkspaceSettings(config, resolved);
+        // Get next mountain name
+        const index = settings.nextMountainIndex ?? 0;
+        const mountainName = MOUNTAIN_NAMES[index % MOUNTAIN_NAMES.length] ?? 'everest';
+        // Build branch name with optional prefix
+        const prefix = settings.branchPrefix ?? '';
+        const branchName = prefix + mountainName;
+        // Detect base branch: user setting > git detected > fallback
+        let baseBranch = settings.defaultBranch;
+        if (!baseBranch) {
+            const detected = await detectGitRepo(resolved);
+            baseBranch = detected.defaultBranch ?? 'main';
+        }
+        // Create git worktree at <workspacePath>/.worktrees/<mountainName>
+        const worktreePath = path.join(resolved, '.worktrees', mountainName);
+        try {
+            // Ensure .worktrees/ is in .gitignore
+            const gitignorePath = path.join(resolved, '.gitignore');
+            try {
+                const existing = await fs.promises.readFile(gitignorePath, 'utf8');
+                if (!existing.includes('.worktrees/')) {
+                    await fs.promises.appendFile(gitignorePath, '\n.worktrees/\n');
+                }
+            }
+            catch {
+                await fs.promises.writeFile(gitignorePath, '.worktrees/\n');
+            }
+            await exec('git', ['worktree', 'add', '-b', branchName, worktreePath, baseBranch], { cwd: resolved });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: `Failed to create worktree: ${msg}` });
+            return;
+        }
+        // Increment mountain counter AFTER successful creation (don't skip names on failure)
+        setWorkspaceSettings(configPath, config, resolved, {
+            nextMountainIndex: index + 1,
+        });
+        res.json({ branchName, mountainName, worktreePath });
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/current-branch — current checked-out branch for a path
+    // -------------------------------------------------------------------------
+    router.get('/current-branch', async (req, res) => {
+        const workspacePath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        if (!workspacePath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        const branch = await getCurrentBranch(path.resolve(workspacePath));
+        res.json({ branch });
+    });
+    // -------------------------------------------------------------------------
+    // GET /workspaces/autocomplete — path prefix autocomplete
+    // -------------------------------------------------------------------------
+    router.get('/autocomplete', async (req, res) => {
+        const prefix = typeof req.query.prefix === 'string' ? req.query.prefix : '';
+        if (!prefix) {
+            res.json({ suggestions: [] });
+            return;
+        }
+        const expanded = prefix.startsWith('~')
+            ? path.join(process.env.HOME ?? '~', prefix.slice(1))
+            : prefix;
+        let dirToRead;
+        let partialName;
+        if (expanded.endsWith('/') || expanded.endsWith(path.sep)) {
+            // User typed a trailing slash — list immediate children of that dir
+            dirToRead = expanded;
+            partialName = '';
+        }
+        else {
+            dirToRead = path.dirname(expanded);
+            partialName = path.basename(expanded).toLowerCase();
+        }
+        let suggestions = [];
+        try {
+            const entries = await fs.promises.readdir(dirToRead, { withFileTypes: true });
+            suggestions = entries
+                .filter((e) => {
+                if (!e.isDirectory())
+                    return false;
+                if (e.name.startsWith('.'))
+                    return false;
+                if (!partialName)
+                    return true;
+                return e.name.toLowerCase().startsWith(partialName);
+            })
+                .map((e) => path.join(dirToRead, e.name))
+                .slice(0, 20); // cap results
+        }
+        catch {
+            // Directory doesn't exist or permission denied — return empty
+        }
+        res.json({ suggestions });
+    });
+    return router;
+}

package/dist/server/ws.js

@@ -1,8 +1,5 @@
 import { WebSocketServer } from 'ws';
 import * as sessions from './sessions.js';
-import { onSdkEvent, sendMessage as sdkSendMessage, handlePermission as sdkHandlePermission } from './sdk-handler.js';
-const BACKPRESSURE_HIGH = 1024 * 1024; // 1MB
-const BACKPRESSURE_LOW = 512 * 1024; // 512KB
 function parseCookies(cookieHeader) {
     const cookies = {};
     if (!cookieHeader)
@@ -50,7 +47,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             });
             return;
         }
-        // PTY/SDK channel: /ws/:sessionId
+        // PTY channel: /ws/:sessionId
         const match = request.url && request.url.match(/^\/ws\/([a-f0-9]+)$/);
         if (!match) {
             socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
@@ -74,16 +71,6 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
         const session = sessionMap.get(ws);
         if (!session)
             return;
-        if (session.mode === 'sdk') {
-            handleSdkConnection(ws, session);
-            return;
-        }
-        // PTY mode — existing behavior
-        if (session.mode !== 'pty') {
-            ws.close(1008, 'Session mode does not support PTY streaming');
-            return;
-        }
-        const ptySession = session;
         let dataDisposable = null;
         let exitDisposable = null;
         function attachToPty(ptyProcess) {
@@ -91,7 +78,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
             // Replay scrollback
-            for (const chunk of ptySession.scrollback) {
+            for (const chunk of session.scrollback) {
                 if (ws.readyState === ws.OPEN)
                     ws.send(chunk);
             }
@@ -104,100 +91,52 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
                     ws.close(1000);
             });
         }
-        attachToPty(ptySession.pty);
+        attachToPty(session.pty);
         const ptyReplacedHandler = (newPty) => attachToPty(newPty);
-        ptySession.onPtyReplacedCallbacks.push(ptyReplacedHandler);
+        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
         ws.on('message', (msg) => {
             const str = msg.toString();
             try {
                 const parsed = JSON.parse(str);
                 if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
-                    sessions.resize(ptySession.id, parsed.cols, parsed.rows);
+                    sessions.resize(session.id, parsed.cols, parsed.rows);
                     return;
                 }
             }
             catch (_) { }
-            // Use ptySession.pty dynamically so writes go to current PTY
-            ptySession.pty.write(str);
+            // Branch rename interception: prepend rename prompt before the user's first message
+            if (session.needsBranchRename) {
+                if (!session._renameBuffer)
+                    session._renameBuffer = '';
+                const enterIndex = str.indexOf('\r');
+                if (enterIndex === -1) {
+                    // No Enter yet — buffer and pass through so the user sees echo
+                    session._renameBuffer += str;
+                    session.pty.write(str);
+                    return;
+                }
+                // Enter detected — inject rename prompt before the user's message
+                const buffered = session._renameBuffer;
+                const beforeEnter = buffered + str.slice(0, enterIndex);
+                const afterEnter = str.slice(enterIndex); // includes the \r
+                const renamePrompt = `Before doing anything else, rename the current git branch using \`git branch -m <new-name>\`. Choose a short, descriptive kebab-case branch name based on the task below.${session.branchRenamePrompt ? ' User preferences: ' + session.branchRenamePrompt : ''} Do not ask for confirmation — just rename and proceed.\n\n`;
+                const clearLine = '\x15'; // Ctrl+U clears the current input line
+                session.pty.write(clearLine + renamePrompt + beforeEnter + afterEnter);
+                session.needsBranchRename = false;
+                delete session._renameBuffer;
+                return;
+            }
+            // Use session.pty dynamically so writes go to current PTY
+            session.pty.write(str);
         });
         ws.on('close', () => {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
-            const idx = ptySession.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
             if (idx !== -1)
-                ptySession.onPtyReplacedCallbacks.splice(idx, 1);
+                session.onPtyReplacedCallbacks.splice(idx, 1);
         });
     });
-    function handleSdkConnection(ws, session) {
-        // Send session info
-        const sessionInfo = JSON.stringify({
-            type: 'session_info',
-            mode: 'sdk',
-            sessionId: session.id,
-        });
-        if (ws.readyState === ws.OPEN)
-            ws.send(sessionInfo);
-        // Replay stored events (send as-is — client expects raw SdkEvent shape)
-        for (const event of session.events) {
-            if (ws.readyState !== ws.OPEN)
-                break;
-            ws.send(JSON.stringify(event));
-        }
-        // Subscribe to live events with backpressure
-        let paused = false;
-        const unsubscribe = onSdkEvent(session.id, (event) => {
-            if (ws.readyState !== ws.OPEN)
-                return;
-            // Backpressure check
-            if (ws.bufferedAmount > BACKPRESSURE_HIGH) {
-                paused = true;
-                return;
-            }
-            ws.send(JSON.stringify(event));
-        });
-        // Periodically check if we can resume
-        const backpressureInterval = setInterval(() => {
-            if (paused && ws.bufferedAmount < BACKPRESSURE_LOW) {
-                paused = false;
-            }
-        }, 100);
-        // Handle incoming messages
-        ws.on('message', (msg) => {
-            const str = msg.toString();
-            try {
-                const parsed = JSON.parse(str);
-                if (parsed.type === 'message' && typeof parsed.text === 'string') {
-                    if (parsed.text.length > 100_000)
-                        return;
-                    sdkSendMessage(session.id, parsed.text);
-                    return;
-                }
-                if (parsed.type === 'permission' && typeof parsed.requestId === 'string' && typeof parsed.approved === 'boolean') {
-                    sdkHandlePermission(session.id, parsed.requestId, parsed.approved);
-                    return;
-                }
-                if (parsed.type === 'resize' && typeof parsed.cols === 'number' && typeof parsed.rows === 'number') {
-                    // TODO: wire up companion shell — currently open_companion message is unhandled server-side
-                    return;
-                }
-                if (parsed.type === 'open_companion') {
-                    // TODO: spawn companion PTY in session CWD and relay via terminal_data/terminal_exit frames
-                    return;
-                }
-            }
-            catch (_) {
-                // Not JSON — ignore for SDK sessions
-            }
-        });
-        ws.on('close', () => {
-            unsubscribe();
-            clearInterval(backpressureInterval);
-        });
-        ws.on('error', () => {
-            unsubscribe();
-            clearInterval(backpressureInterval);
-        });
-    }
     sessions.onIdleChange((sessionId, idle) => {
         broadcastEvent('session-idle-changed', { sessionId, idle });
     });