cursorconnect 0.1.0 → 0.1.2

package/bridge-runtime/dist/relay.js

@@ -0,0 +1,397 @@
+import express from 'express';
+import { createServer } from 'http';
+import { randomBytes, timingSafeEqual } from 'crypto';
+import { basename } from 'path';
+import { readAllowedMediaFile, resolveMediaPathParam } from './media-path.js';
+import { Server as SocketServer } from 'socket.io';
+import { mergeSidebarWithJsonl } from './sidebar-merge.js';
+import { transcribeAudioBuffer } from './openai-transcribe.js';
+import { extensionForMime, saveUploadedImage } from './image-upload-store.js';
+import { RelayUpstream } from './relay-upstream.js';
+export class Relay {
+    stateManager;
+    commandExecutor;
+    cdpBridge;
+    jsonlIndex;
+    messageDebugStore;
+    domExtractor;
+    lastJsonlIndex = { repos: [], updatedAt: 0 };
+    config;
+    app = express();
+    httpServer = createServer(this.app);
+    io;
+    tokens = new Set();
+    upstream = null;
+    constructor(config, stateManager, commandExecutor, cdpBridge, jsonlIndex, messageDebugStore, domExtractor) {
+        this.stateManager = stateManager;
+        this.commandExecutor = commandExecutor;
+        this.cdpBridge = cdpBridge;
+        this.jsonlIndex = jsonlIndex;
+        this.messageDebugStore = messageDebugStore;
+        this.domExtractor = domExtractor;
+        this.config = config;
+        this.io = new SocketServer(this.httpServer, {
+            cors: { origin: true, credentials: true },
+        });
+        this.setupHttp();
+        this.setupSocket();
+        this.wireEvents();
+        if (this.config.relayUrl) {
+            if (!this.config.relayToken) {
+                console.warn('[relay] RELAY_URL set but RELAY_TOKEN empty — upstream disabled');
+            }
+            else {
+                this.upstream = new RelayUpstream(this.config, (event, ...args) => {
+                    this.handleRemoteClientEvent(event, ...args);
+                });
+                this.upstream.connect();
+            }
+        }
+    }
+    listen() {
+        return new Promise((resolve) => {
+            this.httpServer.listen(this.config.serverPort, this.config.serverHost, () => {
+                console.log(`[relay] http://${this.config.serverHost}:${this.config.serverPort}`);
+                resolve();
+            });
+        });
+    }
+    get authEnabled() {
+        return this.config.webappPassword.length > 0;
+    }
+    checkMediaAuth(req) {
+        if (!this.authEnabled)
+            return true;
+        const token = (typeof req.query.token === 'string' ? req.query.token : undefined) ||
+            (typeof req.headers.authorization === 'string'
+                ? req.headers.authorization.replace(/^Bearer\s+/i, '')
+                : undefined);
+        return Boolean(token && this.tokens.has(token));
+    }
+    setupHttp() {
+        this.app.get('/health', (_req, res) => {
+            res.json({ ok: true, cdp: this.cdpBridge.getClient()?.isConnected() ?? false });
+        });
+        this.app.get('/debug/messages', (_req, res) => {
+            const state = this.stateManager.getState();
+            res.json({
+                latest: this.messageDebugStore.latest(),
+                history: this.messageDebugStore.list(),
+                activeComposerId: state.activeComposerId,
+                domMessageCount: state.messages.length,
+                lastError: state.lastError,
+            });
+        });
+        this.app.get('/media/file', (req, res) => {
+            if (!this.checkMediaAuth(req)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const filePath = resolveMediaPathParam(String(req.query.path ?? ''));
+            if (!filePath) {
+                res.status(400).json({ error: 'path required' });
+                return;
+            }
+            const file = readAllowedMediaFile(filePath);
+            if (!file) {
+                res.status(404).json({ error: 'Not found' });
+                return;
+            }
+            res.setHeader('Content-Type', file.contentType);
+            res.setHeader('Cache-Control', 'private, max-age=3600');
+            res.send(file.data);
+        });
+        this.app.post('/api/upload-image', express.json({ limit: '12mb' }), async (req, res) => {
+            if (!this.checkMediaAuth(req)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const imageB64 = String(req.body?.imageBase64 ?? '');
+            const mimeType = String(req.body?.mimeType ?? 'image/jpeg');
+            if (!imageB64) {
+                res.status(400).json({ error: 'imageBase64 required' });
+                return;
+            }
+            let buffer;
+            try {
+                buffer = Buffer.from(imageB64, 'base64');
+            }
+            catch {
+                res.status(400).json({ error: 'Invalid imageBase64' });
+                return;
+            }
+            if (buffer.length < 32) {
+                res.status(400).json({ error: 'Image too small' });
+                return;
+            }
+            if (buffer.length > 10 * 1024 * 1024) {
+                res.status(413).json({ error: 'Image too large (max 10 MB)' });
+                return;
+            }
+            if (!extensionForMime(mimeType)) {
+                res.status(400).json({ error: 'Unsupported image type' });
+                return;
+            }
+            try {
+                const path = await saveUploadedImage(buffer, mimeType);
+                res.json({ path });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        this.app.post('/api/transcribe', express.json({ limit: '12mb' }), async (req, res) => {
+            if (!this.checkMediaAuth(req)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const apiKey = this.config.openaiApiKey;
+            if (!apiKey) {
+                res.status(503).json({
+                    error: 'OPENAI_API_KEY not set on bridge (add to bridge/.env)',
+                });
+                return;
+            }
+            const audioB64 = String(req.body?.audioBase64 ?? '');
+            const mimeType = String(req.body?.mimeType ?? 'audio/m4a');
+            if (!audioB64) {
+                res.status(400).json({ error: 'audioBase64 required' });
+                return;
+            }
+            let audio;
+            try {
+                audio = Buffer.from(audioB64, 'base64');
+            }
+            catch {
+                res.status(400).json({ error: 'Invalid audioBase64' });
+                return;
+            }
+            if (audio.length < 32) {
+                res.status(400).json({ error: 'Recording too short' });
+                return;
+            }
+            if (audio.length > 10 * 1024 * 1024) {
+                res.status(413).json({ error: 'Recording too large (max 10 MB)' });
+                return;
+            }
+            try {
+                const text = await transcribeAudioBuffer(apiKey, audio, mimeType, this.config.openaiTranscribeModel);
+                res.json({ text });
+            }
+            catch (err) {
+                console.warn('[relay] transcribe:', err.message);
+                res.status(502).json({ error: err.message });
+            }
+        });
+        this.app.post('/api/login', express.json(), (req, res) => {
+            if (!this.authEnabled) {
+                res.json({ token: 'open' });
+                return;
+            }
+            const pw = String(req.body?.password ?? '');
+            const expected = Buffer.from(this.config.webappPassword);
+            const got = Buffer.from(pw);
+            if (expected.length !== got.length || !timingSafeEqual(expected, got)) {
+                res.status(401).json({ error: 'Invalid password' });
+                return;
+            }
+            const token = randomBytes(24).toString('hex');
+            this.tokens.add(token);
+            res.json({ token });
+        });
+    }
+    setupSocket() {
+        this.io.use((socket, next) => {
+            if (!this.authEnabled)
+                return next();
+            const token = socket.handshake.auth?.token;
+            if (token && this.tokens.has(token))
+                return next();
+            return next(new Error('Unauthorized'));
+        });
+        this.io.on('connection', (socket) => this.onConnect(socket));
+    }
+    broadcast(event, payload) {
+        this.io.emit(event, payload);
+        this.upstream?.emit(event, payload);
+    }
+    wireEvents() {
+        this.stateManager.on('state:full', (state) => {
+            this.broadcast('state:full', state);
+            this.emitAgentsIndex();
+        });
+        this.stateManager.on('state:patch', (patch) => {
+            this.broadcast('state:patch', patch);
+            if (patch.sidebarRepos || patch.composerIdByTitle)
+                this.emitAgentsIndex();
+        });
+        this.jsonlIndex.on('agents:index', (index) => {
+            this.lastJsonlIndex = index;
+            this.emitAgentsIndex();
+        });
+        this.jsonlIndex.on('agent:history', (history) => this.broadcast('agent:history', history));
+    }
+    emitAgentsIndex() {
+        const sidebar = this.stateManager.getState().sidebarRepos;
+        const merged = mergeSidebarWithJsonl(sidebar, this.lastJsonlIndex, this.stateManager.getState().composerIdByTitle);
+        this.broadcast('agents:index', merged);
+    }
+    pushFullStateToRemote() {
+        this.broadcast('state:full', this.stateManager.getState());
+        void this.jsonlIndex.rebuild().then((index) => {
+            this.lastJsonlIndex = index;
+            this.broadcast('agents:index', mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle));
+        });
+    }
+    async trySwitchWindowForAgent(agentId) {
+        const projectDir = this.jsonlIndex.findProjectDirForAgent(agentId);
+        if (!projectDir)
+            return;
+        const folder = basename(projectDir);
+        const repoSlug = folder.includes('-Projects-')
+            ? (folder.split('-Projects-').pop() ?? '')
+            : folder;
+        const repoName = repoSlug.replace(/-/g, ' ').toLowerCase();
+        if (!repoName)
+            return;
+        await this.cdpBridge.refreshWindows();
+        const match = this.cdpBridge.windows.find((w) => {
+            const t = w.title.toLowerCase();
+            return t.includes(repoName) || repoName.split(' ').every((wrd) => t.includes(wrd));
+        });
+        if (match && match.id !== this.cdpBridge.activeTargetId) {
+            await this.cdpBridge.switchWindow(match.id);
+            console.log(`[relay] CDP → window "${match.title}" for agent ${agentId.slice(0, 8)}`);
+        }
+    }
+    handleRemoteClientEvent(event, ...args) {
+        if (event === 'relay:sync') {
+            this.pushFullStateToRemote();
+            return;
+        }
+        const reply = (ev, payload) => this.broadcast(ev, payload);
+        this.dispatchClientEvent(event, args, reply);
+    }
+    onConnect(socket) {
+        socket.emit('state:full', this.stateManager.getState());
+        void this.jsonlIndex.rebuild().then((index) => {
+            this.lastJsonlIndex = index;
+            socket.emit('agents:index', mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle));
+        });
+        const reply = (ev, payload) => {
+            socket.emit(ev, payload);
+        };
+        socket.on('command', async (payload) => {
+            await this.runCommand(payload, reply);
+        });
+        socket.on('agents:history', async (data) => {
+            await this.runAgentsHistory(data, reply);
+        });
+        socket.on('agents:subscribe', async (data) => {
+            await this.runAgentsSubscribe(data);
+        });
+        socket.on('agents:unsubscribe', (data) => {
+            this.runAgentsUnsubscribe(data);
+        });
+        socket.on('agents:focus', async (data) => {
+            await this.runAgentsFocus(data, reply);
+        });
+        socket.on('agents:refresh', () => {
+            void this.jsonlIndex.rebuild();
+        });
+        socket.on('disconnect', () => {
+            /* subscriptions stay global — one phone session typical */
+        });
+    }
+    dispatchClientEvent(event, args, reply) {
+        if (event === 'command') {
+            void this.runCommand(args[0], reply);
+            return;
+        }
+        if (event === 'agents:history') {
+            void this.runAgentsHistory(args[0], reply);
+            return;
+        }
+        if (event === 'agents:subscribe') {
+            void this.runAgentsSubscribe(args[0]);
+            return;
+        }
+        if (event === 'agents:unsubscribe') {
+            this.runAgentsUnsubscribe(args[0]);
+            return;
+        }
+        if (event === 'agents:focus') {
+            void this.runAgentsFocus(args[0], reply);
+            return;
+        }
+        if (event === 'agents:refresh') {
+            void this.jsonlIndex.rebuild();
+        }
+    }
+    async runCommand(payload, reply) {
+        console.log(`[relay] command ${payload.type} id=${payload.id}`);
+        if (payload.type === 'switch_window' && payload.windowId) {
+            await this.cdpBridge.refreshWindows();
+            await this.cdpBridge.switchWindow(payload.windowId);
+            this.stateManager.patchNow({
+                windows: this.cdpBridge.windows,
+                activeWindowId: this.cdpBridge.activeTargetId,
+            });
+            this.domExtractor.pollNow();
+            return;
+        }
+        const result = await this.commandExecutor.execute(payload);
+        reply('command:result', result);
+        if (payload.type === 'stop_agent' && result.ok) {
+            this.stateManager.patchNow({
+                agentWorking: false,
+                agentStatus: undefined,
+                agentStatusMessage: undefined,
+                composerDraft: undefined,
+                composerDraftImages: undefined,
+            });
+            this.domExtractor.pollNow();
+        }
+    }
+    async runAgentsHistory({ agentId, title }, reply) {
+        const history = await this.jsonlIndex.loadHistory(agentId, {
+            title,
+            composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+        });
+        reply('agents:history', history);
+    }
+    async runAgentsSubscribe({ agentId, title, focus, }) {
+        if (!agentId)
+            return;
+        this.jsonlIndex.subscribe(agentId, title);
+        this.stateManager.patchNow({ lastError: undefined });
+        await this.trySwitchWindowForAgent(agentId);
+        if (focus === false)
+            return;
+        const result = await this.commandExecutor.execute({
+            id: `subscribe-focus-${Date.now()}`,
+            type: 'focus_agent',
+            agentId,
+            tabTitle: title,
+        });
+        if (!result.ok) {
+            console.warn('[relay] subscribe focus (non-fatal):', result.error);
+        }
+    }
+    runAgentsUnsubscribe({ agentId }) {
+        if (agentId)
+            this.jsonlIndex.unsubscribe(agentId);
+    }
+    async runAgentsFocus({ agentId, title }, reply) {
+        if (!agentId)
+            return;
+        await this.trySwitchWindowForAgent(agentId);
+        const result = await this.commandExecutor.execute({
+            id: `focus-${Date.now()}`,
+            type: 'focus_agent',
+            agentId,
+            tabTitle: title,
+        });
+        reply('command:result', result);
+    }
+}

package/bridge-runtime/dist/sidebar-merge.d.ts

@@ -0,0 +1,4 @@
+import type { AgentsIndex, RepoGroup } from './types.js';
+export { normalizeAgentTitle } from './agent-title-match.js';
+/** Prefer Cursor DOM sidebar order/names; attach JSONL ids when titles match. */
+export declare function mergeSidebarWithJsonl(sidebarRepos: RepoGroup[] | undefined, jsonl: AgentsIndex, composerIdByTitle?: Record<string, string>): AgentsIndex;

package/bridge-runtime/dist/sidebar-merge.js

@@ -0,0 +1,47 @@
+import { matchJsonlAgentForSidebarTitle, normalizeAgentTitle, } from './agent-title-match.js';
+export { normalizeAgentTitle } from './agent-title-match.js';
+/** Prefer Cursor DOM sidebar order/names; attach JSONL ids when titles match. */
+export function mergeSidebarWithJsonl(sidebarRepos, jsonl, composerIdByTitle) {
+    if (!sidebarRepos?.length)
+        return jsonl;
+    const byTitle = new Map();
+    for (const repo of jsonl.repos) {
+        for (const agent of repo.agents) {
+            byTitle.set(normalizeAgentTitle(agent.title), agent);
+            if (agent.preview)
+                byTitle.set(normalizeAgentTitle(agent.preview), agent);
+        }
+    }
+    const repos = sidebarRepos.map((section) => ({
+        id: section.id,
+        name: section.name,
+        path: section.path,
+        agents: section.agents.map((row) => {
+            const fuzzy = matchJsonlAgentForSidebarTitle(row.title, jsonl, composerIdByTitle);
+            if (fuzzy) {
+                return {
+                    ...fuzzy,
+                    title: row.title,
+                    isWorking: row.isWorking ?? fuzzy.isWorking,
+                    hasUnread: row.hasUnread ?? fuzzy.hasUnread,
+                    needsAttention: row.needsAttention ?? fuzzy.needsAttention,
+                };
+            }
+            const match = byTitle.get(normalizeAgentTitle(row.title));
+            if (match) {
+                return {
+                    ...match,
+                    title: row.title,
+                    isWorking: row.isWorking ?? match.isWorking,
+                    hasUnread: row.hasUnread ?? match.hasUnread,
+                    needsAttention: row.needsAttention ?? match.needsAttention,
+                };
+            }
+            return {
+                ...row,
+                id: row.id || `title:${normalizeAgentTitle(row.title)}`,
+            };
+        }),
+    }));
+    return { repos, updatedAt: Date.now() };
+}

package/bridge-runtime/dist/state-manager.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from 'events';
+import type { CursorState, CursorWindow, WindowSnapshot } from './types.js';
+export declare class StateManager extends EventEmitter {
+    private state;
+    private debounceMs;
+    private debounceTimer;
+    private pendingPatch;
+    constructor(debounceMs: number);
+    getState(): CursorState;
+    onExtraction(partial: CursorState | null, error?: string): void;
+    onConnectionChanged(connected: boolean): void;
+    updateWindows(windows: CursorWindow[], activeWindowId: string): void;
+    updateWindowSnapshots(snapshots: WindowSnapshot[]): void;
+    private queuePatch;
+    /** Immediate patch (e.g. after stop_agent) — skips debounce wait. */
+    patchNow(patch: Partial<CursorState>): void;
+    private flush;
+    emitFull(): void;
+}

package/bridge-runtime/dist/state-manager.js

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'events';
+const emptyState = () => ({
+    connected: false,
+    windows: [],
+    windowSnapshots: [],
+    tabs: [],
+    messages: [],
+    todos: [],
+    queuedMessages: [],
+    pendingApprovals: [],
+    updatedAt: Date.now(),
+});
+export class StateManager extends EventEmitter {
+    state = emptyState();
+    debounceMs;
+    debounceTimer = null;
+    pendingPatch = {};
+    constructor(debounceMs) {
+        super();
+        this.debounceMs = debounceMs;
+    }
+    getState() {
+        return this.state;
+    }
+    onExtraction(partial, error) {
+        if (!partial) {
+            this.queuePatch({ lastError: error, updatedAt: Date.now() });
+            return;
+        }
+        this.queuePatch({
+            ...partial,
+            connected: true,
+            pendingApprovals: partial.pendingApprovals ?? [],
+            lastError: undefined,
+            updatedAt: Date.now(),
+        });
+    }
+    onConnectionChanged(connected) {
+        this.queuePatch({ connected, updatedAt: Date.now() });
+    }
+    updateWindows(windows, activeWindowId) {
+        this.queuePatch({ windows, activeWindowId, updatedAt: Date.now() });
+    }
+    updateWindowSnapshots(snapshots) {
+        this.queuePatch({ windowSnapshots: snapshots, updatedAt: Date.now() });
+    }
+    queuePatch(patch) {
+        Object.assign(this.pendingPatch, patch);
+        if (this.debounceTimer)
+            return;
+        this.debounceTimer = setTimeout(() => this.flush(), this.debounceMs);
+    }
+    /** Immediate patch (e.g. after stop_agent) — skips debounce wait. */
+    patchNow(patch) {
+        Object.assign(this.pendingPatch, patch);
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.flush();
+    }
+    flush() {
+        this.debounceTimer = null;
+        const patch = this.pendingPatch;
+        this.pendingPatch = {};
+        const next = { ...this.state, ...patch };
+        const diff = {};
+        for (const key of Object.keys(patch)) {
+            if (JSON.stringify(next[key]) !== JSON.stringify(this.state[key])) {
+                diff[key] = next[key];
+            }
+        }
+        this.state = next;
+        if (Object.keys(diff).length > 0) {
+            this.emit('state:patch', diff);
+        }
+    }
+    emitFull() {
+        this.emit('state:full', this.state);
+    }
+}