claude-remote-cli 3.0.6 → 3.1.0

package/dist/server/workspaces.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -7,6 +8,12 @@ import { loadConfig, saveConfig, getWorkspaceSettings, setWorkspaceSettings } fr
 import { listBranches, getActivityFeed, getCiStatus, getPrForBranch, switchBranch, getCurrentBranch } from './git.js';
 import { MOUNTAIN_NAMES } from './types.js';
 const execFileAsync = promisify(execFile);
+const BROWSE_DENYLIST = new Set([
+    'node_modules', '.git', '.Trash', '__pycache__',
+    '.cache', '.npm', '.yarn', '.nvm',
+]);
+const BROWSE_MAX_ENTRIES = 100;
+const BULK_MAX_PATHS = 50;
 // ---------------------------------------------------------------------------
 // Exported helpers
 // ---------------------------------------------------------------------------
@@ -159,6 +166,60 @@ export function createWorkspaceRouter(deps) {
         res.json({ removed: resolved });
     });
     // -------------------------------------------------------------------------
+    // POST /workspaces/bulk — add multiple workspaces at once
+    // -------------------------------------------------------------------------
+    router.post('/bulk', async (req, res) => {
+        const body = req.body;
+        const rawPaths = body.paths;
+        if (!Array.isArray(rawPaths) || rawPaths.length === 0) {
+            res.status(400).json({ error: 'paths array is required' });
+            return;
+        }
+        if (rawPaths.length > BULK_MAX_PATHS) {
+            res.status(400).json({ error: `Too many paths (max ${BULK_MAX_PATHS})` });
+            return;
+        }
+        const config = getConfig();
+        const existing = new Set(config.workspaces ?? []);
+        const added = [];
+        const errors = [];
+        for (const rawPath of rawPaths) {
+            if (typeof rawPath !== 'string' || !rawPath) {
+                errors.push({ path: String(rawPath), error: 'Invalid path' });
+                continue;
+            }
+            let resolved;
+            try {
+                resolved = await validateWorkspacePath(rawPath);
+            }
+            catch (err) {
+                errors.push({ path: rawPath, error: err instanceof Error ? err.message : String(err) });
+                continue;
+            }
+            if (existing.has(resolved)) {
+                errors.push({ path: rawPath, error: 'Already exists' });
+                continue;
+            }
+            const { isGitRepo, defaultBranch } = await detectGitRepo(resolved, exec);
+            existing.add(resolved);
+            added.push({ path: resolved, name: path.basename(resolved), isGitRepo, defaultBranch });
+            // Store detected default branch in per-workspace settings
+            if (isGitRepo && defaultBranch) {
+                if (!config.workspaceSettings)
+                    config.workspaceSettings = {};
+                config.workspaceSettings[resolved] = {
+                    ...config.workspaceSettings[resolved],
+                    defaultBranch,
+                };
+            }
+        }
+        if (added.length > 0) {
+            config.workspaces = [...(config.workspaces ?? []), ...added.map((a) => a.path)];
+            saveConfig(configPath, config);
+        }
+        res.status(201).json({ added, errors });
+    });
+    // -------------------------------------------------------------------------
     // GET /workspaces/dashboard — aggregated PR + activity data for a workspace
     // -------------------------------------------------------------------------
     router.get('/dashboard', async (req, res) => {
@@ -414,6 +475,96 @@ export function createWorkspaceRouter(deps) {
         res.json({ branch });
     });
     // -------------------------------------------------------------------------
+    // GET /workspaces/browse — browse filesystem directories for tree UI
+    // -------------------------------------------------------------------------
+    router.get('/browse', async (req, res) => {
+        const rawPath = typeof req.query.path === 'string' ? req.query.path : '~';
+        const prefix = typeof req.query.prefix === 'string' ? req.query.prefix : '';
+        const showHidden = req.query.showHidden === 'true';
+        // Resolve ~ to home directory
+        const expanded = rawPath === '~' || rawPath.startsWith('~/')
+            ? path.join(os.homedir(), rawPath.slice(1))
+            : rawPath;
+        const resolved = path.resolve(expanded);
+        // Validate path
+        let stat;
+        try {
+            stat = await fs.promises.stat(resolved);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'EACCES') {
+                res.status(403).json({ error: 'Permission denied' });
+            }
+            else {
+                res.status(400).json({ error: `Path does not exist: ${resolved}` });
+            }
+            return;
+        }
+        if (!stat.isDirectory()) {
+            res.status(400).json({ error: `Not a directory: ${resolved}` });
+            return;
+        }
+        // Read directory entries
+        let dirents;
+        try {
+            dirents = await fs.promises.readdir(resolved, { withFileTypes: true });
+        }
+        catch {
+            res.status(403).json({ error: 'Cannot read directory' });
+            return;
+        }
+        // Filter to directories only, apply denylist, hidden filter, prefix filter
+        let dirs = dirents.filter((d) => {
+            if (!d.isDirectory())
+                return false;
+            if (BROWSE_DENYLIST.has(d.name))
+                return false;
+            // Also check if name contains a path separator component in denylist
+            // e.g. "Library/Caches" — we check the full name, not path components
+            if (!showHidden && d.name.startsWith('.'))
+                return false;
+            if (prefix && !d.name.toLowerCase().startsWith(prefix.toLowerCase()))
+                return false;
+            return true;
+        });
+        // Sort alphabetically case-insensitive
+        dirs.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+        const total = dirs.length;
+        const truncated = dirs.length > BROWSE_MAX_ENTRIES;
+        if (truncated)
+            dirs = dirs.slice(0, BROWSE_MAX_ENTRIES);
+        // Enrich each entry with isGitRepo and hasChildren (parallelized)
+        const entries = await Promise.all(dirs.map(async (d) => {
+            const entryPath = path.join(resolved, d.name);
+            // Check for .git directory (isGitRepo)
+            let isGitRepo = false;
+            try {
+                const gitStat = await fs.promises.stat(path.join(entryPath, '.git'));
+                isGitRepo = gitStat.isDirectory();
+            }
+            catch {
+                // not a git repo
+            }
+            // Check if has at least one subdirectory child (hasChildren)
+            let hasChildren = false;
+            try {
+                const children = await fs.promises.readdir(entryPath, { withFileTypes: true });
+                hasChildren = children.some((c) => c.isDirectory() && !BROWSE_DENYLIST.has(c.name));
+            }
+            catch {
+                // can't read — treat as no children
+            }
+            return {
+                name: d.name,
+                path: entryPath,
+                isGitRepo,
+                hasChildren,
+            };
+        }));
+        res.json({ resolved, entries, truncated, total });
+    });
+    // -------------------------------------------------------------------------
     // GET /workspaces/autocomplete — path prefix autocomplete
     // -------------------------------------------------------------------------
     router.get('/autocomplete', async (req, res) => {

package/dist/server/ws.js

@@ -1,5 +1,46 @@
 import { WebSocketServer } from 'ws';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import * as sessions from './sessions.js';
+import { onSdkEvent, sendMessage as sdkSendMessage, handlePermission as sdkHandlePermission } from './sdk-handler.js';
+import { writeMeta } from './config.js';
+const execFileAsync = promisify(execFile);
+const BACKPRESSURE_HIGH = 1024 * 1024; // 1MB
+const BACKPRESSURE_LOW = 512 * 1024; // 512KB
+const BRANCH_POLL_INTERVAL_MS = 3000;
+const BRANCH_POLL_MAX_ATTEMPTS = 10;
+const RENAME_CORE = `rename the current git branch using \`git branch -m <new-name>\` to a short, descriptive kebab-case name based on the task I'm asking about. Do not include any ticket numbers or prefixes.`;
+const SDK_BRANCH_RENAME_INSTRUCTION = `Before responding to my message, first ${RENAME_CORE} After renaming, proceed with my request normally.\n\n`;
+function startBranchWatcher(session, broadcastEvent, cfgPath) {
+    const originalBranch = session.branchName;
+    let attempts = 0;
+    const timer = setInterval(async () => {
+        attempts++;
+        if (attempts > BRANCH_POLL_MAX_ATTEMPTS) {
+            clearInterval(timer);
+            return;
+        }
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: session.cwd });
+            const currentBranch = stdout.trim();
+            if (currentBranch && currentBranch !== originalBranch) {
+                clearInterval(timer);
+                session.branchName = currentBranch;
+                session.displayName = currentBranch;
+                broadcastEvent('session-renamed', { sessionId: session.id, branchName: currentBranch, displayName: currentBranch });
+                writeMeta(cfgPath, {
+                    worktreePath: session.repoPath,
+                    displayName: currentBranch,
+                    lastActivity: new Date().toISOString(),
+                    branchName: currentBranch,
+                });
+            }
+        }
+        catch {
+            // git command failed — session cwd may not exist yet, retry
+        }
+    }, BRANCH_POLL_INTERVAL_MS);
+}
 function parseCookies(cookieHeader) {
     const cookies = {};
     if (!cookieHeader)
@@ -14,7 +55,7 @@ function parseCookies(cookieHeader) {
     });
     return cookies;
 }
-function setupWebSocket(server, authenticatedTokens, watcher) {
+function setupWebSocket(server, authenticatedTokens, watcher, configPath) {
     const wss = new WebSocketServer({ noServer: true });
     const eventClients = new Set();
     function broadcastEvent(type, data) {
@@ -47,7 +88,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             });
             return;
         }
-        // PTY channel: /ws/:sessionId
+        // PTY/SDK 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');
@@ -71,6 +112,16 @@ 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) {
@@ -78,7 +129,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
             // Replay scrollback
-            for (const chunk of session.scrollback) {
+            for (const chunk of ptySession.scrollback) {
                 if (ws.readyState === ws.OPEN)
                     ws.send(chunk);
             }
@@ -91,52 +142,132 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
                     ws.close(1000);
             });
         }
-        attachToPty(session.pty);
+        attachToPty(ptySession.pty);
         const ptyReplacedHandler = (newPty) => attachToPty(newPty);
-        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
+        ptySession.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(session.id, parsed.cols, parsed.rows);
+                    sessions.resize(ptySession.id, parsed.cols, parsed.rows);
                     return;
                 }
             }
             catch (_) { }
             // Branch rename interception: prepend rename prompt before the user's first message
-            if (session.needsBranchRename) {
-                if (!session._renameBuffer)
-                    session._renameBuffer = '';
+            if (ptySession.needsBranchRename) {
+                if (!ptySession._renameBuffer)
+                    ptySession._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);
+                    ptySession._renameBuffer += str;
+                    ptySession.pty.write(str);
                     return;
                 }
                 // Enter detected — inject rename prompt before the user's message
-                const buffered = session._renameBuffer;
+                const buffered = ptySession._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 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.${ptySession.branchRenamePrompt ? ' User preferences: ' + ptySession.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;
+                ptySession.pty.write(clearLine + renamePrompt + beforeEnter + afterEnter);
+                ptySession.needsBranchRename = false;
+                delete ptySession._renameBuffer;
+                if (configPath)
+                    startBranchWatcher(ptySession, broadcastEvent, configPath);
                 return;
             }
-            // Use session.pty dynamically so writes go to current PTY
-            session.pty.write(str);
+            // Use ptySession.pty dynamically so writes go to current PTY
+            ptySession.pty.write(str);
         });
         ws.on('close', () => {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
-            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            const idx = ptySession.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
             if (idx !== -1)
-                session.onPtyReplacedCallbacks.splice(idx, 1);
+                ptySession.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;
+                    if (session.needsBranchRename) {
+                        session.needsBranchRename = false;
+                        sdkSendMessage(session.id, SDK_BRANCH_RENAME_INSTRUCTION + parsed.text);
+                        if (configPath)
+                            startBranchWatcher(session, broadcastEvent, configPath);
+                    }
+                    else {
+                        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 });
     });

package/dist/test/branch-rename.test.js

@@ -0,0 +1,28 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { MOUNTAIN_NAMES } from '../server/types.js';
+describe('MOUNTAIN_NAMES', () => {
+    test('contains 30 mountain names', () => {
+        assert.equal(MOUNTAIN_NAMES.length, 30);
+    });
+    test('all names are lowercase kebab-case', () => {
+        for (const name of MOUNTAIN_NAMES) {
+            assert.match(name, /^[a-z][a-z0-9-]*$/, `Mountain name "${name}" is not kebab-case`);
+        }
+    });
+    test('no duplicate names', () => {
+        const unique = new Set(MOUNTAIN_NAMES);
+        assert.equal(unique.size, MOUNTAIN_NAMES.length);
+    });
+    test('cycling wraps around at array length', () => {
+        let idx = 28;
+        const name1 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name2 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name3 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        assert.equal(name1, 'whitney');
+        assert.equal(name2, 'hood');
+        assert.equal(name3, 'everest'); // wraps back to start
+    });
+});

package/dist/test/fs-browse.test.js

@@ -0,0 +1,202 @@
+import { describe, test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import { createWorkspaceRouter } from '../server/workspaces.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+before(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fs-browse-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    // Create a directory tree for testing
+    //   tmpDir/
+    //     browsable/
+    //       visible-dir/
+    //         nested/
+    //       .hidden-dir/
+    //       git-repo/
+    //         .git/
+    //       empty-dir/
+    //       node_modules/
+    //       file.txt
+    const browsable = path.join(tmpDir, 'browsable');
+    fs.mkdirSync(path.join(browsable, 'visible-dir', 'nested'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, '.hidden-dir'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'git-repo', '.git'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'empty-dir'), { recursive: true });
+    fs.mkdirSync(path.join(browsable, 'node_modules'), { recursive: true });
+    fs.writeFileSync(path.join(browsable, 'file.txt'), 'not a directory');
+    // Create 110 dirs to test truncation
+    const manyDir = path.join(tmpDir, 'many');
+    fs.mkdirSync(manyDir);
+    for (let i = 0; i < 110; i++) {
+        fs.mkdirSync(path.join(manyDir, `dir-${String(i).padStart(3, '0')}`));
+    }
+    // Save a config so the router can load it
+    saveConfig(configPath, { ...DEFAULTS, workspaces: [] });
+    // Start a test server
+    const app = express();
+    app.use(express.json());
+    app.use('/workspaces', createWorkspaceRouter({ configPath }));
+    await new Promise((resolve) => {
+        server = app.listen(0, '127.0.0.1', () => resolve());
+    });
+    const addr = server.address();
+    if (typeof addr === 'object' && addr) {
+        baseUrl = `http://127.0.0.1:${addr.port}`;
+    }
+});
+after(() => {
+    server?.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+async function browse(query = {}) {
+    const params = new URLSearchParams(query);
+    const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+    assert.equal(res.status, 200, `Expected 200 but got ${res.status}`);
+    return res.json();
+}
+describe('GET /workspaces/browse', () => {
+    test('lists directories in a given path', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        assert.equal(data.resolved, browsable);
+        const names = data.entries.map((e) => e.name);
+        // Should include visible directories but not files or denylisted dirs
+        assert.ok(names.includes('visible-dir'), 'should include visible-dir');
+        assert.ok(names.includes('git-repo'), 'should include git-repo');
+        assert.ok(names.includes('empty-dir'), 'should include empty-dir');
+        assert.ok(!names.includes('file.txt'), 'should exclude files');
+        assert.ok(!names.includes('node_modules'), 'should exclude node_modules');
+    });
+    test('hides dotfiles by default', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(!names.includes('.hidden-dir'), 'should exclude hidden dirs by default');
+    });
+    test('shows dotfiles when showHidden=true', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, showHidden: 'true' });
+        const names = data.entries.map((e) => e.name);
+        assert.ok(names.includes('.hidden-dir'), 'should include hidden dirs when showHidden');
+        // .git should still be excluded (in denylist)
+        assert.ok(!names.includes('.git'), 'should still exclude .git');
+    });
+    test('filters by prefix', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, prefix: 'vis' });
+        assert.equal(data.entries.length, 1);
+        assert.equal(data.entries[0].name, 'visible-dir');
+    });
+    test('prefix filter is case-insensitive', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable, prefix: 'VIS' });
+        assert.equal(data.entries.length, 1);
+        assert.equal(data.entries[0].name, 'visible-dir');
+    });
+    test('detects isGitRepo correctly', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const gitRepo = data.entries.find((e) => e.name === 'git-repo');
+        const visibleDir = data.entries.find((e) => e.name === 'visible-dir');
+        assert.ok(gitRepo, 'git-repo entry should exist');
+        assert.equal(gitRepo.isGitRepo, true, 'git-repo should have isGitRepo=true');
+        assert.ok(visibleDir, 'visible-dir entry should exist');
+        assert.equal(visibleDir.isGitRepo, false, 'visible-dir should have isGitRepo=false');
+    });
+    test('detects hasChildren correctly', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const visibleDir = data.entries.find((e) => e.name === 'visible-dir');
+        const emptyDir = data.entries.find((e) => e.name === 'empty-dir');
+        assert.ok(visibleDir, 'visible-dir entry should exist');
+        assert.equal(visibleDir.hasChildren, true, 'visible-dir should have children');
+        assert.ok(emptyDir, 'empty-dir entry should exist');
+        assert.equal(emptyDir.hasChildren, false, 'empty-dir should not have children');
+    });
+    test('truncates at 100 entries', async () => {
+        const manyDir = path.join(tmpDir, 'many');
+        const data = await browse({ path: manyDir });
+        assert.equal(data.entries.length, 100);
+        assert.equal(data.truncated, true);
+        assert.equal(data.total, 110);
+    });
+    test('sorts alphabetically case-insensitive', async () => {
+        const browsable = path.join(tmpDir, 'browsable');
+        const data = await browse({ path: browsable });
+        const names = data.entries.map((e) => e.name);
+        const sorted = [...names].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        assert.deepEqual(names, sorted, 'entries should be sorted alphabetically');
+    });
+    test('returns 400 for non-existent path', async () => {
+        const params = new URLSearchParams({ path: path.join(tmpDir, 'nonexistent') });
+        const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+        assert.equal(res.status, 400);
+    });
+    test('returns 400 for file path', async () => {
+        const params = new URLSearchParams({ path: path.join(tmpDir, 'browsable', 'file.txt') });
+        const res = await fetch(`${baseUrl}/workspaces/browse?${params}`);
+        assert.equal(res.status, 400);
+    });
+    test('defaults to home directory when no path given', async () => {
+        const data = await browse();
+        assert.equal(data.resolved, os.homedir());
+        // Should have at least some entries (home dir is not empty)
+        assert.ok(data.entries.length > 0, 'home directory should have entries');
+    });
+});
+describe('POST /workspaces/bulk', () => {
+    test('adds multiple workspaces', async () => {
+        const dir1 = path.join(tmpDir, 'browsable', 'visible-dir');
+        const dir2 = path.join(tmpDir, 'browsable', 'empty-dir');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [dir1, dir2] }),
+        });
+        assert.equal(res.status, 201);
+        const data = await res.json();
+        assert.equal(data.added.length, 2);
+        assert.equal(data.errors.length, 0);
+    });
+    test('rejects duplicate workspaces', async () => {
+        const dir1 = path.join(tmpDir, 'browsable', 'visible-dir');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [dir1] }),
+        });
+        assert.equal(res.status, 201);
+        const data = await res.json();
+        assert.equal(data.added.length, 0);
+        assert.equal(data.errors.length, 1);
+        assert.ok(data.errors[0].error.includes('Already exists'));
+    });
+    test('returns 400 for empty paths array', async () => {
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [] }),
+        });
+        assert.equal(res.status, 400);
+    });
+    test('handles mixed valid/invalid paths', async () => {
+        const validDir = path.join(tmpDir, 'browsable', 'git-repo');
+        const invalidDir = path.join(tmpDir, 'nonexistent');
+        const res = await fetch(`${baseUrl}/workspaces/bulk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ paths: [validDir, invalidDir] }),
+        });
+        assert.equal(res.status, 201);
+        const data = await res.json();
+        assert.equal(data.added.length, 1);
+        assert.equal(data.errors.length, 1);
+    });
+});