claude-remote-cli 2.2.2 → 2.3.0

package/dist/server/index.js

@@ -155,7 +155,7 @@ async function main() {
     const app = express();
     app.use(express.json({ limit: '15mb' }));
     app.use(cookieParser());
-    app.use(express.static(path.join(__dirname, '..', '..', 'public')));
+    app.use(express.static(path.join(__dirname, '..', 'frontend')));
     const requireAuth = (req, res, next) => {
         const token = req.cookies && req.cookies.token;
         if (!token || !authenticatedTokens.has(token)) {
@@ -236,6 +236,57 @@ async function main() {
             res.json([]);
         }
     });
+    // 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 /worktrees?repo=<path> — list worktrees; omit repo to scan all repos in all rootDirs
     app.get('/worktrees', requireAuth, (req, res) => {
         const repoParam = typeof req.query.repo === 'string' ? req.query.repo : undefined;

package/dist/test/auth.test.js

@@ -0,0 +1,41 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { hashPin, verifyPin, isRateLimited, recordFailedAttempt, generateCookieToken, _resetForTesting, } from '../server/auth.js';
+test('hashPin returns bcrypt hash starting with $2b$', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    assert.ok(hash.startsWith('$2b$'), `Expected hash to start with $2b$, got: ${hash}`);
+});
+test('verifyPin returns true for correct PIN', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    const result = await verifyPin('1234', hash);
+    assert.strictEqual(result, true);
+});
+test('verifyPin returns false for wrong PIN', async () => {
+    _resetForTesting();
+    const hash = await hashPin('1234');
+    const result = await verifyPin('9999', hash);
+    assert.strictEqual(result, false);
+});
+test('rate limiter blocks after 5 failures', () => {
+    _resetForTesting();
+    const ip = '127.0.0.1';
+    for (let i = 0; i < 5; i++) {
+        recordFailedAttempt(ip);
+    }
+    assert.strictEqual(isRateLimited(ip), true);
+});
+test('rate limiter allows under threshold', () => {
+    _resetForTesting();
+    const ip = '127.0.0.1';
+    for (let i = 0; i < 4; i++) {
+        recordFailedAttempt(ip);
+    }
+    assert.strictEqual(isRateLimited(ip), false);
+});
+test('generateCookieToken returns non-empty string', () => {
+    _resetForTesting();
+    const token = generateCookieToken();
+    assert.ok(typeof token === 'string' && token.length > 0);
+});

package/dist/test/clipboard.test.js

@@ -0,0 +1,12 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { detectClipboardTool, setClipboardImage } from '../server/clipboard.js';
+describe('clipboard', () => {
+    it('detectClipboardTool returns a string or null', () => {
+        const result = detectClipboardTool();
+        assert.ok(result === null || typeof result === 'string');
+    });
+    it('setClipboardImage rejects unsupported mime types', async () => {
+        await assert.rejects(() => setClipboardImage('/tmp/test.txt', 'text/plain'), /Unsupported/);
+    });
+});

package/dist/test/config.test.js

@@ -0,0 +1,99 @@
+import { test, before, after, afterEach } 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 { DEFAULTS, loadConfig, saveConfig, ensureMetaDir, readMeta, writeMeta, deleteMeta } from '../server/config.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-remote-cli-config-test-'));
+});
+afterEach(() => {
+    for (const entry of fs.readdirSync(tmpDir, { withFileTypes: true })) {
+        const fullPath = path.join(tmpDir, entry.name);
+        if (entry.isDirectory()) {
+            fs.rmSync(fullPath, { recursive: true });
+        }
+        else {
+            fs.unlinkSync(fullPath);
+        }
+    }
+});
+after(() => {
+    fs.rmdirSync(tmpDir);
+});
+test('loadConfig loads a JSON config file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const data = { port: 4000, host: '127.0.0.1' };
+    fs.writeFileSync(configPath, JSON.stringify(data), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.port, 4000);
+    assert.equal(config.host, '127.0.0.1');
+});
+test('loadConfig merges with defaults for missing fields', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({ port: 9000 }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.port, 9000);
+    assert.equal(config.host, DEFAULTS.host);
+    assert.equal(config.cookieTTL, DEFAULTS.cookieTTL);
+    assert.deepEqual(config.repos, DEFAULTS.repos);
+    assert.equal(config.claudeCommand, DEFAULTS.claudeCommand);
+    assert.deepEqual(config.claudeArgs, DEFAULTS.claudeArgs);
+});
+test('loadConfig throws if config file not found', () => {
+    const configPath = path.join(tmpDir, 'nonexistent.json');
+    assert.throws(() => loadConfig(configPath), /Config file not found/);
+});
+test('saveConfig writes JSON with 2-space indent', () => {
+    const configPath = path.join(tmpDir, 'output.json');
+    const config = { port: 3456, host: '0.0.0.0' };
+    saveConfig(configPath, config);
+    const raw = fs.readFileSync(configPath, 'utf8');
+    assert.equal(raw, JSON.stringify(config, null, 2));
+});
+test('DEFAULTS has expected keys and values', () => {
+    assert.equal(DEFAULTS.host, '0.0.0.0');
+    assert.equal(DEFAULTS.port, 3456);
+    assert.equal(DEFAULTS.cookieTTL, '24h');
+    assert.deepEqual(DEFAULTS.repos, []);
+    assert.equal(DEFAULTS.claudeCommand, 'claude');
+    assert.deepEqual(DEFAULTS.claudeArgs, []);
+});
+test('ensureMetaDir creates worktree-meta directory', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    ensureMetaDir(configPath);
+    const metaPath = path.join(tmpDir, 'worktree-meta');
+    assert.ok(fs.existsSync(metaPath));
+});
+test('writeMeta creates and readMeta reads metadata file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const meta = { worktreePath: '/tmp/test-worktree', displayName: 'My Feature', lastActivity: '2026-02-22T00:00:00.000Z' };
+    writeMeta(configPath, meta);
+    const read = readMeta(configPath, '/tmp/test-worktree');
+    assert.deepEqual(read, meta);
+});
+test('readMeta returns null for non-existent metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    const result = readMeta(configPath, '/no/such/worktree');
+    assert.equal(result, null);
+});
+test('writeMeta overwrites existing metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    writeMeta(configPath, { worktreePath: '/tmp/wt', displayName: 'Old Name', lastActivity: '2026-01-01T00:00:00.000Z' });
+    writeMeta(configPath, { worktreePath: '/tmp/wt', displayName: 'New Name', lastActivity: '2026-02-22T00:00:00.000Z' });
+    const read = readMeta(configPath, '/tmp/wt');
+    assert.equal(read.displayName, 'New Name');
+    assert.equal(read.lastActivity, '2026-02-22T00:00:00.000Z');
+});
+test('deleteMeta removes metadata file', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    writeMeta(configPath, { worktreePath: '/tmp/del-test', displayName: 'To Delete', lastActivity: '2026-02-22T00:00:00.000Z' });
+    assert.ok(readMeta(configPath, '/tmp/del-test'));
+    deleteMeta(configPath, '/tmp/del-test');
+    assert.equal(readMeta(configPath, '/tmp/del-test'), null);
+});
+test('deleteMeta is a no-op for non-existent metadata', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    assert.doesNotThrow(() => deleteMeta(configPath, '/no/such/path'));
+});

package/dist/test/paths.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// At runtime, __dirname resolves to dist/test/.
+// The server runs from dist/server/, which uses path.join(__dirname, '..', '..', ...)
+// to reach the project root. This test verifies that relationship is correct.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// This test file is at dist/test/, server is at dist/server/ — same depth
+const projectRoot = path.resolve(__dirname, '..', '..');
+test('project root from dist/ contains frontend/ directory', () => {
+    const frontendDir = path.join(projectRoot, 'frontend');
+    assert.ok(fs.existsSync(frontendDir), `Expected frontend/ at ${frontendDir}`);
+});
+test('project root from dist/ contains frontend/index.html', () => {
+    const indexHtml = path.join(projectRoot, 'frontend', 'index.html');
+    assert.ok(fs.existsSync(indexHtml), `Expected frontend/index.html at ${indexHtml}`);
+});
+test('dist/server/ exists after compilation', () => {
+    const serverDir = path.join(projectRoot, 'dist', 'server');
+    assert.ok(fs.existsSync(serverDir), `Expected dist/server/ at ${serverDir}`);
+});
+test('server index.ts uses correct path depth to reach dist/frontend/', async () => {
+    // Read the source file and verify the path pattern
+    const indexSource = fs.readFileSync(path.join(projectRoot, 'server', 'index.ts'), 'utf8');
+    // Static serving must go up one level from dist/server/ to dist/, then into frontend/
+    assert.ok(indexSource.includes("path.join(__dirname, '..', 'frontend')"), "express.static must resolve dist/frontend/ one level up from dist/server/");
+    // Config fallback must also go up two levels
+    assert.ok(indexSource.includes("path.join(__dirname, '..', '..', 'config.json')"), 'CONFIG_PATH must resolve config.json two levels up from dist/server/');
+});

package/dist/test/service.test.js

@@ -0,0 +1,43 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import * as service from '../server/service.js';
+test('getPlatform returns macos or linux', () => {
+    const platform = service.getPlatform();
+    assert.ok(platform === 'macos' || platform === 'linux', 'Expected macos or linux, got ' + platform);
+});
+test('getServicePaths returns expected keys', () => {
+    const paths = service.getServicePaths();
+    assert.ok(paths.servicePath, 'missing servicePath');
+    assert.equal(typeof paths.label, 'string', 'label should be a string');
+    assert.ok('logDir' in paths, 'missing logDir key');
+});
+test('generateServiceFile for macos contains plist XML', () => {
+    const content = service.generateServiceFile('macos', {
+        nodePath: '/usr/local/bin/node',
+        scriptPath: '/usr/local/lib/node_modules/claude-remote-cli/bin/claude-remote-cli.js',
+        configPath: '/Users/test/.config/claude-remote-cli/config.json',
+        port: '3456',
+        host: '0.0.0.0',
+        logDir: '/Users/test/.config/claude-remote-cli/logs',
+    });
+    assert.match(content, /<!DOCTYPE plist/, 'should be plist XML');
+    assert.match(content, /com\.claude-remote-cli/, 'should have label');
+    assert.match(content, /RunAtLoad/, 'should have RunAtLoad');
+    assert.match(content, /KeepAlive/, 'should have KeepAlive');
+    assert.match(content, /3456/, 'should include port');
+});
+test('generateServiceFile for linux contains systemd unit', () => {
+    const content = service.generateServiceFile('linux', {
+        nodePath: '/usr/bin/node',
+        scriptPath: '/usr/lib/node_modules/claude-remote-cli/bin/claude-remote-cli.js',
+        configPath: '/home/test/.config/claude-remote-cli/config.json',
+        port: '3456',
+        host: '0.0.0.0',
+        logDir: null,
+    });
+    assert.match(content, /\[Unit\]/, 'should have Unit section');
+    assert.match(content, /\[Service\]/, 'should have Service section');
+    assert.match(content, /\[Install\]/, 'should have Install section');
+    assert.match(content, /Restart=on-failure/, 'should restart on failure');
+    assert.match(content, /3456/, 'should include port');
+});

package/dist/test/sessions.test.js

@@ -0,0 +1,217 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert';
+import * as sessions from '../server/sessions.js';
+// Track created session IDs so we can clean up after each test
+const createdIds = [];
+afterEach(() => {
+    // Kill any remaining sessions created during tests
+    for (const id of createdIds) {
+        try {
+            const session = sessions.get(id);
+            if (session) {
+                sessions.kill(id);
+            }
+        }
+        catch {
+            // Already killed or exited, ignore
+        }
+    }
+    createdIds.length = 0;
+});
+describe('sessions', () => {
+    it('list returns empty array initially', () => {
+        const result = sessions.list();
+        assert.ok(Array.isArray(result));
+        assert.strictEqual(result.length, 0);
+    });
+    it('create spawns PTY and adds session to registry', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+            cols: 80,
+            rows: 24,
+        });
+        createdIds.push(result.id);
+        assert.ok(result.id, 'should have an id');
+        assert.strictEqual(result.repoName, 'test-repo');
+        assert.strictEqual(result.repoPath, '/tmp');
+        assert.ok(typeof result.pid === 'number', 'should have a numeric pid');
+        assert.ok(result.createdAt, 'should have a createdAt timestamp');
+        assert.strictEqual('pty' in result, false, 'should not expose pty object');
+        const list = sessions.list();
+        assert.strictEqual(list.length, 1);
+        assert.strictEqual(list[0]?.id, result.id);
+    });
+    it('get returns session by id', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session, 'should return the session');
+        assert.strictEqual(session.id, result.id);
+        assert.strictEqual(session.repoName, 'test-repo');
+        assert.ok(session.pty, 'get should include the pty object');
+    });
+    it('get returns undefined for nonexistent id', () => {
+        const session = sessions.get('nonexistent-id-12345');
+        assert.strictEqual(session, undefined);
+    });
+    it('kill removes session from registry', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        sessions.kill(result.id);
+        // Remove from tracking since it's already killed
+        createdIds.splice(createdIds.indexOf(result.id), 1);
+        const session = sessions.get(result.id);
+        assert.strictEqual(session, undefined, 'session should be removed after kill');
+        const list = sessions.list();
+        assert.ok(!list.some((s) => s.id === result.id), 'killed session should not appear in list');
+    });
+    it('kill throws for nonexistent session', () => {
+        assert.throws(() => sessions.kill('nonexistent-id'), /Session not found/);
+    });
+    it('resize throws for nonexistent session', () => {
+        assert.throws(() => sessions.resize('nonexistent-id', 100, 40), /Session not found/);
+    });
+    it('write sends data to PTY stdin', (_, done) => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+            cols: 80,
+            rows: 24,
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        let output = '';
+        session.pty.onData((data) => {
+            output += data;
+            if (output.includes('hello')) {
+                done();
+            }
+        });
+        sessions.write(result.id, 'hello');
+    });
+    it('write throws for nonexistent session', () => {
+        assert.throws(() => sessions.write('nonexistent-id', 'data'), /Session not found/);
+    });
+    it('session starts as not idle', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.strictEqual(session.idle, false);
+    });
+    it('list includes idle field', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const list = sessions.list();
+        assert.strictEqual(list.length, 1);
+        assert.strictEqual(list[0]?.idle, false);
+    });
+    it('type defaults to worktree when not specified', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.type, 'worktree');
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.strictEqual(session.type, 'worktree');
+    });
+    it('type is set to repo when specified', () => {
+        const result = sessions.create({
+            type: 'repo',
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.type, 'repo');
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.strictEqual(session.type, 'repo');
+    });
+    it('list includes type field', () => {
+        const r1 = sessions.create({
+            type: 'repo',
+            repoName: 'repo-a',
+            repoPath: '/tmp/a',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(r1.id);
+        const r2 = sessions.create({
+            type: 'worktree',
+            repoName: 'repo-b',
+            repoPath: '/tmp/b',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(r2.id);
+        const list = sessions.list();
+        const repoSession = list.find(function (s) { return s.id === r1.id; });
+        const wtSession = list.find(function (s) { return s.id === r2.id; });
+        assert.ok(repoSession);
+        assert.strictEqual(repoSession.type, 'repo');
+        assert.ok(wtSession);
+        assert.strictEqual(wtSession.type, 'worktree');
+    });
+    it('findRepoSession returns undefined when no repo sessions exist', () => {
+        const result = sessions.findRepoSession('/tmp');
+        assert.strictEqual(result, undefined);
+    });
+    it('findRepoSession returns repo session matching repoPath', () => {
+        const created = sessions.create({
+            type: 'repo',
+            repoName: 'test-repo',
+            repoPath: '/tmp/my-repo',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(created.id);
+        const found = sessions.findRepoSession('/tmp/my-repo');
+        assert.ok(found, 'should find the repo session');
+        assert.strictEqual(found.id, created.id);
+        assert.strictEqual(found.type, 'repo');
+    });
+    it('findRepoSession ignores worktree sessions at same path', () => {
+        const created = sessions.create({
+            type: 'worktree',
+            repoName: 'test-repo',
+            repoPath: '/tmp/my-repo',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(created.id);
+        const found = sessions.findRepoSession('/tmp/my-repo');
+        assert.strictEqual(found, undefined, 'should not match worktree sessions');
+    });
+});

package/dist/test/version.test.js

@@ -0,0 +1,34 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+function semverLessThan(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+test('semverLessThan returns true when major is lower', () => {
+    assert.equal(semverLessThan('1.0.0', '2.0.0'), true);
+});
+test('semverLessThan returns true when minor is lower', () => {
+    assert.equal(semverLessThan('1.1.0', '1.2.0'), true);
+});
+test('semverLessThan returns true when patch is lower', () => {
+    assert.equal(semverLessThan('1.1.1', '1.1.2'), true);
+});
+test('semverLessThan returns false for equal versions', () => {
+    assert.equal(semverLessThan('1.1.1', '1.1.1'), false);
+});
+test('semverLessThan returns false when current is greater', () => {
+    assert.equal(semverLessThan('2.0.0', '1.9.9'), false);
+});
+test('semverLessThan handles major version jumps', () => {
+    assert.equal(semverLessThan('1.9.9', '2.0.0'), true);
+});
+test('semverLessThan handles two-segment versions gracefully', () => {
+    assert.equal(semverLessThan('1.0', '1.1'), true);
+});

package/dist/test/worktrees.test.js

@@ -0,0 +1,57 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { WORKTREE_DIRS, isValidWorktreePath } from '../server/watcher.js';
+describe('worktree directories constant', () => {
+    it('should include both .worktrees and .claude/worktrees', () => {
+        assert.deepEqual(WORKTREE_DIRS, ['.worktrees', '.claude/worktrees']);
+    });
+});
+describe('isValidWorktreePath', () => {
+    it('should reject paths not inside any worktree directory', () => {
+        assert.equal(isValidWorktreePath('/some/random/path'), false);
+    });
+    it('should accept paths inside .worktrees/', () => {
+        assert.equal(isValidWorktreePath('/Users/me/code/repo/.worktrees/my-worktree'), true);
+    });
+    it('should accept paths inside .claude/worktrees/', () => {
+        assert.equal(isValidWorktreePath('/Users/me/code/repo/.claude/worktrees/my-worktree'), true);
+    });
+    it('should not match partial .worktrees paths', () => {
+        assert.equal(isValidWorktreePath('/Users/me/.worktrees-fake/foo'), false);
+    });
+});
+describe('branch name to directory name', () => {
+    it('should replace slashes with dashes', () => {
+        const branchName = 'dy/feat/my-feature';
+        const dirName = branchName.replace(/\//g, '-');
+        assert.equal(dirName, 'dy-feat-my-feature');
+    });
+    it('should leave flat branch names unchanged', () => {
+        const branchName = 'my-feature';
+        const dirName = branchName.replace(/\//g, '-');
+        assert.equal(dirName, 'my-feature');
+    });
+});
+describe('CLI worktree arg parsing', () => {
+    it('should extract --yolo and leave other args intact', () => {
+        const args = ['add', './.worktrees/my-feature', '-b', 'my-feature', '--yolo'];
+        const hasYolo = args.includes('--yolo');
+        const gitArgs = args.filter(a => a !== '--yolo');
+        assert.equal(hasYolo, true);
+        assert.deepEqual(gitArgs, ['add', './.worktrees/my-feature', '-b', 'my-feature']);
+    });
+    it('should detect missing path for add and use default', () => {
+        // args: ['add', '-b', 'my-feature'] — no positional path (first arg after 'add' starts with '-')
+        const args = ['add', '-b', 'my-feature'];
+        const subArgs = args.slice(1); // after 'add'
+        const hasPositionalPath = subArgs.length > 0 && !subArgs[0].startsWith('-');
+        assert.equal(hasPositionalPath, false);
+    });
+    it('should detect path when provided for add', () => {
+        const args = ['add', './my-path', '-b', 'my-feature'];
+        const subArgs = args.slice(1);
+        const hasPositionalPath = subArgs.length > 0 && !subArgs[0].startsWith('-');
+        assert.equal(hasPositionalPath, true);
+        assert.equal(subArgs[0], './my-path');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",
@@ -8,14 +8,14 @@
     "claude-remote-cli": "dist/bin/claude-remote-cli.js"
   },
   "files": [
-    "dist/bin/",
-    "dist/server/",
-    "public/",
-    "config.example.json"
+    "dist/"
   ],
   "scripts": {
-    "build": "tsc",
-    "start": "tsc && node dist/server/index.js",
+    "build": "tsc && vite build --config frontend/vite.config.ts",
+    "build:server": "tsc",
+    "build:frontend": "vite build --config frontend/vite.config.ts",
+    "dev": "vite --config frontend/vite.config.ts",
+    "start": "tsc && vite build --config frontend/vite.config.ts && node dist/server/index.js",
     "test": "tsc -p tsconfig.test.json && node --test dist/test/*.test.js",
     "postinstall": "chmod +x node_modules/node-pty/prebuilds/darwin-arm64/spawn-helper 2>/dev/null || true"
   },
@@ -39,20 +39,26 @@
   "license": "MIT",
   "author": "Donovan Yohan",
   "dependencies": {
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
     "bcrypt": "^5.1.1",
     "cookie-parser": "^1.4.7",
     "express": "^4.21.0",
     "node-pty": "^1.0.0",
+    "svelte": "^5.53.3",
     "ws": "^8.18.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.2",
+    "@sveltejs/vite-plugin-svelte": "^5.1.1",
     "@types/bcrypt": "^5.0.2",
     "@types/cookie-parser": "^1.4.7",
     "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.13",
     "playwright": "^1.58.2",
-    "typescript": "^5.7.0"
+    "svelte-check": "^4.4.3",
+    "typescript": "^5.7.0",
+    "vite": "^6.4.1"
   }
 }