claude-remote-cli 3.5.4 → 3.7.0

package/dist/server/workspaces.js

@@ -5,6 +5,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { Router } from 'express';
 import { loadConfig, saveConfig, getWorkspaceSettings, setWorkspaceSettings, deleteWorkspaceSettingKeys } from './config.js';
+import { trackEvent } from './analytics.js';
 import { listBranches, getActivityFeed, getCiStatus, getPrForBranch, getUnresolvedCommentCount, switchBranch, getCurrentBranch } from './git.js';
 import { MOUNTAIN_NAMES } from './types.js';
 const execFileAsync = promisify(execFile);
@@ -135,6 +136,7 @@ export function createWorkspaceRouter(deps) {
             };
         }
         saveConfig(configPath, config);
+        trackEvent({ category: 'workspace', action: 'added', target: resolved, properties: { name: path.basename(resolved) } });
         const workspace = {
             path: resolved,
             name: path.basename(resolved),
@@ -163,6 +165,7 @@ export function createWorkspaceRouter(deps) {
         }
         config.workspaces = workspaces.filter((p) => p !== resolved);
         saveConfig(configPath, config);
+        trackEvent({ category: 'workspace', action: 'removed', target: resolved });
         res.json({ removed: resolved });
     });
     // -------------------------------------------------------------------------

package/dist/server/ws.js

@@ -1,84 +1,6 @@
 import { WebSocketServer } from 'ws';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import * as sessions from './sessions.js';
-import { writeMeta } from './config.js';
-import { branchToDisplayName } from './git.js';
-const execFileAsync = promisify(execFile);
-const BRANCH_POLL_INTERVAL_MS = 3000;
-const BRANCH_POLL_MAX_ATTEMPTS = 10;
-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);
-                const displayName = branchToDisplayName(currentBranch);
-                session.branchName = currentBranch;
-                session.displayName = displayName;
-                broadcastEvent('session-renamed', { sessionId: session.id, branchName: currentBranch, displayName });
-                writeMeta(cfgPath, {
-                    worktreePath: session.repoPath,
-                    displayName,
-                    lastActivity: new Date().toISOString(),
-                    branchName: currentBranch,
-                });
-            }
-        }
-        catch {
-            // git command failed — session cwd may not exist yet, retry
-        }
-    }, BRANCH_POLL_INTERVAL_MS);
-}
-/** Sideband branch rename: uses headless claude to generate a branch name from the first message */
-async function spawnBranchRename(session, firstMessage, cfgPath, broadcastEvent) {
-    try {
-        const cleanMessage = firstMessage.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/[\x00-\x1f]/g, ' ').trim();
-        if (!cleanMessage)
-            return;
-        const basePrompt = session.branchRenamePrompt
-            ?? `Output ONLY a short kebab-case git branch name (no explanation, no backticks, no prefix, just the name) that describes this task:`;
-        const prompt = `${basePrompt}\n\n${cleanMessage.slice(0, 500)}`;
-        const { stdout } = await execFileAsync('claude', ['-p', '--model', 'haiku', prompt], {
-            cwd: session.cwd,
-            timeout: 30000,
-        });
-        const branchName = stdout.trim().replace(/`/g, '').replace(/[^a-z0-9-]/gi, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').toLowerCase().slice(0, 60);
-        if (!branchName)
-            return;
-        await execFileAsync('git', ['branch', '-m', branchName], { cwd: session.cwd });
-        // Update session state
-        const displayName = branchToDisplayName(branchName);
-        session.branchName = branchName;
-        session.displayName = displayName;
-        broadcastEvent('session-renamed', {
-            sessionId: session.id,
-            branchName,
-            displayName,
-        });
-        if (cfgPath) {
-            writeMeta(cfgPath, {
-                worktreePath: session.repoPath,
-                displayName,
-                lastActivity: new Date().toISOString(),
-                branchName,
-            });
-        }
-    }
-    catch {
-        // Sideband rename is best-effort — fall back to branch watcher if claude CLI isn't available
-        if (cfgPath)
-            startBranchWatcher(session, broadcastEvent, cfgPath);
-    }
-}
+import { trackEvent } from './analytics.js';
 function parseCookies(cookieHeader) {
     const cookies = {};
     if (!cookieHeader)
@@ -93,7 +15,7 @@ function parseCookies(cookieHeader) {
     });
     return cookies;
 }
-function setupWebSocket(server, authenticatedTokens, watcher, configPath) {
+function setupWebSocket(server, authenticatedTokens, watcher, _configPath) {
     const wss = new WebSocketServer({ noServer: true });
     const eventClients = new Set();
     function broadcastEvent(type, data) {
@@ -184,30 +106,6 @@ function setupWebSocket(server, authenticatedTokens, watcher, configPath) {
                 }
             }
             catch (_) { }
-            // Sideband branch rename: capture first message, pass through unmodified, rename out-of-band
-            if (ptySession.needsBranchRename && ptySession.agentState !== 'waiting-for-input') {
-                ptySession.pty.write(str);
-                return;
-            }
-            if (ptySession.needsBranchRename) {
-                if (!ptySession._renameBuffer)
-                    ptySession._renameBuffer = '';
-                const enterIndex = str.indexOf('\r');
-                if (enterIndex === -1) {
-                    ptySession._renameBuffer += str;
-                    ptySession.pty.write(str); // pass through to PTY normally — user sees their typing
-                    return;
-                }
-                // Enter detected — pass everything through unmodified
-                const buffered = ptySession._renameBuffer;
-                const firstMessage = buffered + str.slice(0, enterIndex);
-                ptySession.pty.write(str); // pass through the Enter key
-                ptySession.needsBranchRename = false;
-                delete ptySession._renameBuffer;
-                // Sideband: spawn headless claude to generate branch name (async, non-blocking)
-                spawnBranchRename(ptySession, firstMessage, configPath, broadcastEvent);
-                return;
-            }
             // Use ptySession.pty dynamically so writes go to current PTY
             ptySession.pty.write(str);
         });
@@ -221,9 +119,15 @@ function setupWebSocket(server, authenticatedTokens, watcher, configPath) {
     });
     sessions.onIdleChange((sessionId, idle) => {
         broadcastEvent('session-idle-changed', { sessionId, idle });
+        if (idle) {
+            trackEvent({ category: 'agent', action: 'idle', target: sessionId, session_id: sessionId });
+        }
     });
     sessions.onStateChange((sessionId, state) => {
         broadcastEvent('session-state-changed', { sessionId, state });
+        if (state === 'waiting-for-input') {
+            trackEvent({ category: 'agent', action: 'waiting-for-input', target: sessionId, session_id: sessionId });
+        }
     });
     sessions.onSessionEnd((sessionId, repoPath, branchName) => {
         broadcastEvent('session-ended', { sessionId, repoPath, branchName });

package/dist/test/analytics.test.js

@@ -0,0 +1,152 @@
+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 Database from 'better-sqlite3';
+import { initAnalytics, closeAnalytics, trackEvent, getDbSize, getDbPath } from '../server/analytics.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-remote-cli-analytics-test-'));
+});
+afterEach(() => {
+    closeAnalytics();
+    // Clean up DB files between tests
+    for (const entry of fs.readdirSync(tmpDir)) {
+        fs.unlinkSync(path.join(tmpDir, entry));
+    }
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+});
+test('initAnalytics creates database and schema', () => {
+    initAnalytics(tmpDir);
+    const dbPath = getDbPath(tmpDir);
+    assert.ok(fs.existsSync(dbPath), 'DB file should exist');
+    const db = new Database(dbPath, { readonly: true });
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    assert.ok(tables.some(t => t.name === 'events'), 'events table should exist');
+    db.close();
+});
+test('trackEvent inserts a row', () => {
+    initAnalytics(tmpDir);
+    trackEvent({
+        category: 'session',
+        action: 'created',
+        target: 'session-123',
+        properties: { workspace: '/proj', agent: 'claude' },
+        session_id: 'session-123',
+        device: 'desktop',
+    });
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].category, 'session');
+    assert.equal(rows[0].action, 'created');
+    assert.equal(rows[0].target, 'session-123');
+    assert.equal(rows[0].device, 'desktop');
+    const props = JSON.parse(rows[0].properties);
+    assert.equal(props.workspace, '/proj');
+    assert.equal(props.agent, 'claude');
+    db.close();
+});
+test('trackEvent handles optional fields as null', () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'ui', action: 'click' });
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].target, null);
+    assert.equal(rows[0].properties, null);
+    assert.equal(rows[0].session_id, null);
+    assert.equal(rows[0].device, null);
+    db.close();
+});
+test('trackEvent is no-op before initAnalytics', () => {
+    // Should not throw
+    trackEvent({ category: 'test', action: 'noop' });
+});
+test('getDbSize returns file size after writes', () => {
+    initAnalytics(tmpDir);
+    const sizeBefore = getDbSize(tmpDir);
+    assert.ok(sizeBefore > 0, 'DB file should have non-zero size after init');
+    for (let i = 0; i < 10; i++) {
+        trackEvent({ category: 'bulk', action: 'test', properties: { i } });
+    }
+    const sizeAfter = getDbSize(tmpDir);
+    assert.ok(sizeAfter >= sizeBefore, 'Size should grow after writes');
+});
+test('getDbSize returns 0 for non-existent path', () => {
+    assert.equal(getDbSize('/nonexistent/path'), 0);
+});
+test('initAnalytics is idempotent (schema already exists)', () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'test', action: 'first' });
+    closeAnalytics();
+    // Re-init should not throw or lose data
+    initAnalytics(tmpDir);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 1);
+    db.close();
+});
+// ── Router endpoint tests ──────────────────────────────────────────────
+// These test the Express Router in isolation (same pattern as fs-browse.test.ts)
+import express from 'express';
+import http from 'node:http';
+import { createAnalyticsRouter } from '../server/analytics.js';
+test('POST /analytics/events batch inserts events', async () => {
+    initAnalytics(tmpDir);
+    const app = express();
+    app.use(express.json());
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise(resolve => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/events`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ events: [
+                { category: 'ui', action: 'click', target: 'test-btn' },
+                { category: 'session', action: 'created' },
+            ] }),
+    });
+    const data = await res.json();
+    assert.equal(data.ok, true);
+    assert.equal(data.count, 2);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 2);
+    db.close();
+    server.close();
+});
+test('GET /analytics/size returns bytes', async () => {
+    initAnalytics(tmpDir);
+    const app = express();
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise(resolve => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/size`);
+    const data = await res.json();
+    assert.ok(data.bytes > 0);
+    server.close();
+});
+test('DELETE /analytics/events clears all events', async () => {
+    initAnalytics(tmpDir);
+    trackEvent({ category: 'test', action: 'to-delete' });
+    const app = express();
+    app.use(express.json());
+    app.use('/analytics', createAnalyticsRouter(tmpDir));
+    const server = http.createServer(app);
+    await new Promise(resolve => server.listen(0, resolve));
+    const port = server.address().port;
+    const res = await fetch(`http://localhost:${port}/analytics/events`, { method: 'DELETE' });
+    const data = await res.json();
+    assert.equal(data.ok, true);
+    const db = new Database(getDbPath(tmpDir), { readonly: true });
+    const rows = db.prepare('SELECT * FROM events').all();
+    assert.equal(rows.length, 0);
+    db.close();
+    server.close();
+});

package/dist/test/hooks.test.js

@@ -0,0 +1,139 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { stripAnsi, semverLessThan, cleanEnv } from '../server/utils.js';
+import { onStateChange, fireStateChange } from '../server/sessions.js';
+describe('stripAnsi', () => {
+    it('strips CSI color sequences', () => {
+        assert.equal(stripAnsi('\x1b[32mhello\x1b[0m'), 'hello');
+    });
+    it('strips CSI bold/reset sequences', () => {
+        assert.equal(stripAnsi('\x1b[1mbold\x1b[0m'), 'bold');
+    });
+    it('strips OSC sequences', () => {
+        assert.equal(stripAnsi('\x1b]0;window title\x07plain'), 'plain');
+    });
+    it('strips cursor movement sequences', () => {
+        assert.equal(stripAnsi('\x1b[2Jhello'), 'hello');
+    });
+    it('preserves plain text', () => {
+        assert.equal(stripAnsi('hello world'), 'hello world');
+    });
+    it('handles empty string', () => {
+        assert.equal(stripAnsi(''), '');
+    });
+    it('strips multiple sequences in one string', () => {
+        assert.equal(stripAnsi('\x1b[32mfoo\x1b[0m and \x1b[1mbar\x1b[0m'), 'foo and bar');
+    });
+});
+describe('semverLessThan', () => {
+    it('returns true when major is lower', () => {
+        assert.equal(semverLessThan('1.0.0', '2.0.0'), true);
+    });
+    it('returns false when major is higher', () => {
+        assert.equal(semverLessThan('2.0.0', '1.0.0'), false);
+    });
+    it('returns true when patch is lower', () => {
+        assert.equal(semverLessThan('1.2.3', '1.2.4'), true);
+    });
+    it('returns false when patch is higher', () => {
+        assert.equal(semverLessThan('1.2.4', '1.2.3'), false);
+    });
+    it('returns false for equal versions', () => {
+        assert.equal(semverLessThan('1.0.0', '1.0.0'), false);
+    });
+    it('strips pre-release tag before comparing — 1.2.3-beta.1 vs 1.2.3 treated as equal', () => {
+        assert.equal(semverLessThan('1.2.3-beta.1', '1.2.3'), false);
+    });
+    it('strips pre-release tag before comparing — 1.2.3-beta.1 vs 1.3.0 treated as less than', () => {
+        assert.equal(semverLessThan('1.2.3-beta.1', '1.3.0'), true);
+    });
+    it('returns true when minor is lower', () => {
+        assert.equal(semverLessThan('1.1.0', '1.2.0'), true);
+    });
+    it('handles major version jumps', () => {
+        assert.equal(semverLessThan('1.9.9', '2.0.0'), true);
+    });
+});
+describe('cleanEnv', () => {
+    it('returns an object that does not contain CLAUDECODE', () => {
+        const originalValue = process.env.CLAUDECODE;
+        process.env.CLAUDECODE = 'some-value';
+        try {
+            const env = cleanEnv();
+            assert.equal(Object.prototype.hasOwnProperty.call(env, 'CLAUDECODE'), false);
+        }
+        finally {
+            if (originalValue === undefined) {
+                delete process.env.CLAUDECODE;
+            }
+            else {
+                process.env.CLAUDECODE = originalValue;
+            }
+        }
+    });
+    it('does not modify original process.env', () => {
+        const originalValue = process.env.CLAUDECODE;
+        process.env.CLAUDECODE = 'test-token';
+        try {
+            cleanEnv();
+            assert.equal(process.env.CLAUDECODE, 'test-token');
+        }
+        finally {
+            if (originalValue === undefined) {
+                delete process.env.CLAUDECODE;
+            }
+            else {
+                process.env.CLAUDECODE = originalValue;
+            }
+        }
+    });
+    it('returns a copy — mutations do not affect process.env', () => {
+        const env = cleanEnv();
+        const testKey = '__CRC_TEST_KEY__';
+        env[testKey] = 'injected';
+        assert.equal(process.env[testKey], undefined);
+    });
+    it('preserves other environment variables', () => {
+        const env = cleanEnv();
+        // PATH is virtually always set; verify it round-trips
+        if (process.env.PATH !== undefined) {
+            assert.equal(env.PATH, process.env.PATH);
+        }
+    });
+});
+describe('fireStateChange callbacks', () => {
+    it('calls a registered onStateChange callback with correct args', () => {
+        const received = [];
+        onStateChange((sessionId, state) => {
+            received.push({ sessionId, state });
+        });
+        fireStateChange('test-session-id', 'processing');
+        const match = received.find(e => e.sessionId === 'test-session-id' && e.state === 'processing');
+        assert.ok(match, 'callback should have been called with the expected sessionId and state');
+    });
+    it('fires multiple registered callbacks', () => {
+        let count = 0;
+        onStateChange(() => { count++; });
+        onStateChange(() => { count++; });
+        fireStateChange('multi-cb-session', 'idle');
+        assert.ok(count >= 2, 'both callbacks should have been invoked');
+    });
+    it('passes idle state to callback', () => {
+        let received;
+        onStateChange((_, state) => { received = state; });
+        fireStateChange('some-session', 'idle');
+        assert.equal(received, 'idle');
+    });
+    it('passes permission-prompt state to callback', () => {
+        let received;
+        onStateChange((_, state) => { received = state; });
+        fireStateChange('some-session', 'permission-prompt');
+        assert.equal(received, 'permission-prompt');
+    });
+    it('passes waiting-for-input state to callback', () => {
+        let received;
+        onStateChange((_, state) => { received = state; });
+        fireStateChange('some-session', 'waiting-for-input');
+        assert.equal(received, 'waiting-for-input');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "3.5.4",
+  "version": "3.7.0",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",
@@ -46,6 +46,7 @@
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
     "bcrypt": "^5.1.1",
+    "better-sqlite3": "^12.8.0",
     "cookie-parser": "^1.4.7",
     "express": "^4.21.0",
     "node-pty": "^1.0.0",
@@ -58,6 +59,7 @@
     "@playwright/test": "^1.58.2",
     "@sveltejs/vite-plugin-svelte": "^5.1.1",
     "@types/bcrypt": "^5.0.2",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/cookie-parser": "^1.4.7",
     "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",