@gricha/perry 0.2.6 → 0.3.0

package/dist/session-manager/manager.js

@@ -0,0 +1,302 @@
+import { RingBuffer } from './ring-buffer';
+import { ClaudeCodeAdapter } from './adapters/claude';
+import { OpenCodeAdapter } from './adapters/opencode';
+import { getContainerName } from '../docker';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
+const DEFAULT_BUFFER_SIZE = 1000;
+export class SessionManager {
+    sessions = new Map();
+    clientIdCounter = 0;
+    generateSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    generateClientId() {
+        return `client-${++this.clientIdCounter}`;
+    }
+    createAdapter(agentType) {
+        switch (agentType) {
+            case 'claude':
+                return new ClaudeCodeAdapter();
+            case 'opencode':
+                return new OpenCodeAdapter();
+            case 'codex':
+                throw new Error('Codex adapter not yet implemented');
+            default:
+                throw new Error(`Unknown agent type: ${agentType}`);
+        }
+    }
+    async startSession(options) {
+        const sessionId = options.sessionId || this.generateSessionId();
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            return sessionId;
+        }
+        const adapter = this.createAdapter(options.agentType);
+        const buffer = new RingBuffer(DEFAULT_BUFFER_SIZE);
+        const info = {
+            id: sessionId,
+            workspaceName: options.workspaceName,
+            agentType: options.agentType,
+            status: 'idle',
+            agentSessionId: options.agentSessionId,
+            model: options.model,
+            startedAt: new Date(),
+            lastActivity: new Date(),
+        };
+        const session = {
+            info,
+            adapter,
+            buffer,
+            clients: new Map(),
+        };
+        adapter.onMessage((message) => {
+            this.handleAdapterMessage(sessionId, message);
+        });
+        adapter.onStatusChange((status) => {
+            this.handleStatusChange(sessionId, status);
+        });
+        adapter.onError((error) => {
+            this.handleAdapterError(sessionId, error);
+        });
+        const isHost = options.workspaceName === HOST_WORKSPACE_NAME;
+        const containerName = isHost ? undefined : getContainerName(options.workspaceName);
+        await adapter.start({
+            workspaceName: options.workspaceName,
+            containerName,
+            agentSessionId: options.agentSessionId,
+            model: options.model,
+            projectPath: options.projectPath,
+            isHost,
+        });
+        this.sessions.set(sessionId, session);
+        return sessionId;
+    }
+    handleAdapterMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.info.lastActivity = new Date();
+        const bufferedMessage = {
+            id: session.buffer.getLatestId() + 1,
+            message,
+            timestamp: Date.now(),
+        };
+        session.buffer.push(bufferedMessage);
+        for (const client of session.clients.values()) {
+            try {
+                client.send(message);
+            }
+            catch {
+                // Client send failed, will be cleaned up on disconnect
+            }
+        }
+    }
+    handleStatusChange(sessionId, status) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.info.status = status;
+        session.info.lastActivity = new Date();
+        const previousAgentSessionId = session.info.agentSessionId;
+        const currentAgentSessionId = session.adapter.getAgentSessionId();
+        if (currentAgentSessionId !== undefined && previousAgentSessionId !== currentAgentSessionId) {
+            session.info.agentSessionId = currentAgentSessionId;
+            const updateMessage = {
+                type: 'system',
+                content: JSON.stringify({ agentSessionId: currentAgentSessionId }),
+                timestamp: new Date().toISOString(),
+            };
+            for (const client of session.clients.values()) {
+                try {
+                    client.send(updateMessage);
+                }
+                catch {
+                    // Client send failed
+                }
+            }
+        }
+    }
+    handleAdapterError(sessionId, error) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.info.status = 'error';
+        session.info.error = error.message;
+        session.info.lastActivity = new Date();
+        const errorMessage = {
+            type: 'error',
+            content: error.message,
+            timestamp: new Date().toISOString(),
+        };
+        for (const client of session.clients.values()) {
+            try {
+                client.send(errorMessage);
+            }
+            catch {
+                // Client send failed
+            }
+        }
+    }
+    connectClient(sessionId, sendFn, options) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        const clientId = this.generateClientId();
+        const client = {
+            id: clientId,
+            send: sendFn,
+        };
+        session.clients.set(clientId, client);
+        if (options?.resumeFromId !== undefined) {
+            const missedMessages = session.buffer.getSince(options.resumeFromId);
+            for (const buffered of missedMessages) {
+                try {
+                    sendFn(buffered.message);
+                }
+                catch {
+                    // Failed to send buffered message
+                }
+            }
+        }
+        else {
+            const allMessages = session.buffer.getAll();
+            for (const buffered of allMessages) {
+                try {
+                    sendFn(buffered.message);
+                }
+                catch {
+                    // Failed to send buffered message
+                }
+            }
+        }
+        const statusMessage = {
+            type: 'system',
+            content: `Connected to session (status: ${session.info.status})`,
+            timestamp: new Date().toISOString(),
+        };
+        try {
+            sendFn(statusMessage);
+        }
+        catch {
+            // Failed to send status
+        }
+        return clientId;
+    }
+    disconnectClient(sessionId, clientId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        const client = session.clients.get(clientId);
+        if (client?.onDisconnect) {
+            client.onDisconnect();
+        }
+        session.clients.delete(clientId);
+    }
+    async sendMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        if (session.info.status === 'running') {
+            throw new Error('Session is already processing a message');
+        }
+        session.info.status = 'running';
+        session.info.lastActivity = new Date();
+        const userMessage = {
+            type: 'user',
+            content: message,
+            timestamp: new Date().toISOString(),
+        };
+        this.handleAdapterMessage(sessionId, userMessage);
+        await session.adapter.sendMessage(message);
+    }
+    async interrupt(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        await session.adapter.interrupt();
+        session.info.status = 'interrupted';
+        session.info.lastActivity = new Date();
+    }
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.info ?? null;
+    }
+    findSession(id) {
+        // First try direct lookup by internal sessionId
+        const direct = this.sessions.get(id);
+        if (direct) {
+            return { sessionId: id, info: direct.info };
+        }
+        // Then search by agentSessionId (Claude session ID)
+        for (const [sessionId, session] of this.sessions) {
+            if (session.info.agentSessionId === id) {
+                return { sessionId, info: session.info };
+            }
+        }
+        return null;
+    }
+    getSessionStatus(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.info.status ?? null;
+    }
+    listActiveSessions(workspaceName) {
+        const sessions = [];
+        for (const session of this.sessions.values()) {
+            if (!workspaceName || session.info.workspaceName === workspaceName) {
+                sessions.push(session.info);
+            }
+        }
+        return sessions;
+    }
+    getBufferedMessages(sessionId, sinceId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return [];
+        if (sinceId !== undefined) {
+            return session.buffer.getSince(sinceId);
+        }
+        return session.buffer.getAll();
+    }
+    async disposeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        for (const client of session.clients.values()) {
+            if (client.onDisconnect) {
+                client.onDisconnect();
+            }
+        }
+        session.clients.clear();
+        await session.adapter.dispose();
+        this.sessions.delete(sessionId);
+    }
+    async disposeWorkspaceSessions(workspaceName) {
+        const toDispose = [];
+        for (const [id, session] of this.sessions) {
+            if (session.info.workspaceName === workspaceName) {
+                toDispose.push(id);
+            }
+        }
+        await Promise.all(toDispose.map((id) => this.disposeSession(id)));
+    }
+    async disposeAll() {
+        const ids = [...this.sessions.keys()];
+        await Promise.all(ids.map((id) => this.disposeSession(id)));
+    }
+    setModel(sessionId, model) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.info.model = model;
+    }
+    hasActiveClients(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session ? session.clients.size > 0 : false;
+    }
+    getClientCount(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.clients.size ?? 0;
+    }
+}
+export const sessionManager = new SessionManager();

package/dist/session-manager/ring-buffer.js

@@ -0,0 +1,66 @@
+export class RingBuffer {
+    capacity;
+    buffer;
+    head = 0;
+    tail = 0;
+    count = 0;
+    nextId = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = Array.from({ length: capacity });
+    }
+    push(item) {
+        const id = this.nextId++;
+        this.buffer[this.tail] = item;
+        this.tail = (this.tail + 1) % this.capacity;
+        if (this.count < this.capacity) {
+            this.count++;
+        }
+        else {
+            this.head = (this.head + 1) % this.capacity;
+        }
+        return id;
+    }
+    getAll() {
+        const result = [];
+        for (let i = 0; i < this.count; i++) {
+            const idx = (this.head + i) % this.capacity;
+            const item = this.buffer[idx];
+            if (item !== undefined) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    getSince(startId) {
+        const oldestId = this.nextId - this.count;
+        if (startId < oldestId) {
+            return this.getAll();
+        }
+        const result = [];
+        const skipCount = startId - oldestId;
+        for (let i = skipCount; i < this.count; i++) {
+            const idx = (this.head + i) % this.capacity;
+            const item = this.buffer[idx];
+            if (item !== undefined) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    getLatestId() {
+        return this.nextId - 1;
+    }
+    getOldestId() {
+        return this.nextId - this.count;
+    }
+    size() {
+        return this.count;
+    }
+    clear() {
+        this.buffer = Array.from({ length: this.capacity });
+        this.head = 0;
+        this.tail = 0;
+        this.count = 0;
+    }
+}

package/dist/session-manager/types.js

@@ -0,0 +1 @@
+export {};

package/dist/session-manager/websocket.js

@@ -0,0 +1,153 @@
+import { BaseWebSocketServer, safeSend } from '../shared/base-websocket';
+import { sessionManager } from './manager';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
+export class LiveChatWebSocketServer extends BaseWebSocketServer {
+    isHostAccessAllowed;
+    agentType;
+    constructor(options) {
+        super(options);
+        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
+        this.agentType = options.agentType;
+    }
+    handleConnection(ws, workspaceName) {
+        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
+        if (isHostMode && !this.isHostAccessAllowed()) {
+            ws.close(4003, 'Host access is disabled');
+            return;
+        }
+        const connection = {
+            ws,
+            workspaceName,
+            sessionId: null,
+            clientId: null,
+            agentType: this.agentType,
+        };
+        this.connections.set(ws, connection);
+        safeSend(ws, JSON.stringify({
+            type: 'connected',
+            workspaceName,
+            agentType: this.agentType,
+            timestamp: new Date().toISOString(),
+        }));
+        ws.on('message', async (data) => {
+            const str = typeof data === 'string' ? data : data.toString();
+            try {
+                const message = JSON.parse(str);
+                if (message.type === 'connect') {
+                    await this.handleConnect(connection, ws, workspaceName, message);
+                    return;
+                }
+                if (message.type === 'disconnect') {
+                    this.handleDisconnect(connection);
+                    return;
+                }
+                if (message.type === 'interrupt') {
+                    if (connection.sessionId) {
+                        await sessionManager.interrupt(connection.sessionId);
+                    }
+                    return;
+                }
+                if (message.type === 'message' && message.content) {
+                    await this.handleMessage(connection, ws, workspaceName, message);
+                }
+            }
+            catch (err) {
+                safeSend(ws, JSON.stringify({
+                    type: 'error',
+                    content: err.message,
+                    timestamp: new Date().toISOString(),
+                }));
+            }
+        });
+        ws.on('close', () => {
+            this.handleDisconnect(connection);
+            this.connections.delete(ws);
+        });
+        ws.on('error', (err) => {
+            console.error(`Live chat WebSocket error:`, err);
+            this.handleDisconnect(connection);
+            this.connections.delete(ws);
+        });
+    }
+    async handleConnect(connection, ws, workspaceName, message) {
+        const agentType = message.agentType || this.agentType;
+        if (message.sessionId) {
+            const existingSession = sessionManager.getSession(message.sessionId);
+            if (existingSession) {
+                connection.sessionId = message.sessionId;
+                const sendFn = (msg) => {
+                    safeSend(ws, JSON.stringify(msg));
+                };
+                const clientId = sessionManager.connectClient(message.sessionId, sendFn, {
+                    resumeFromId: message.resumeFromId,
+                });
+                if (clientId) {
+                    connection.clientId = clientId;
+                    safeSend(ws, JSON.stringify({
+                        type: 'session_joined',
+                        sessionId: message.sessionId,
+                        status: existingSession.status,
+                        agentSessionId: existingSession.agentSessionId,
+                        timestamp: new Date().toISOString(),
+                    }));
+                    return;
+                }
+            }
+        }
+        const sessionId = await sessionManager.startSession({
+            workspaceName,
+            agentType,
+            sessionId: message.sessionId,
+            agentSessionId: message.agentSessionId,
+            model: message.model,
+            projectPath: message.projectPath,
+        });
+        connection.sessionId = sessionId;
+        const sendFn = (msg) => {
+            safeSend(ws, JSON.stringify(msg));
+        };
+        const clientId = sessionManager.connectClient(sessionId, sendFn);
+        connection.clientId = clientId;
+        safeSend(ws, JSON.stringify({
+            type: 'session_started',
+            sessionId,
+            timestamp: new Date().toISOString(),
+        }));
+    }
+    async handleMessage(connection, ws, workspaceName, message) {
+        if (!connection.sessionId) {
+            await this.handleConnect(connection, ws, workspaceName, {
+                type: 'connect',
+                agentType: message.agentType || this.agentType,
+                agentSessionId: message.agentSessionId,
+                model: message.model,
+                projectPath: message.projectPath,
+            });
+        }
+        if (!connection.sessionId) {
+            throw new Error('Failed to create session');
+        }
+        await sessionManager.sendMessage(connection.sessionId, message.content);
+    }
+    handleDisconnect(connection) {
+        if (connection.sessionId && connection.clientId) {
+            sessionManager.disconnectClient(connection.sessionId, connection.clientId);
+            connection.clientId = null;
+        }
+    }
+    cleanupConnection(connection) {
+        this.handleDisconnect(connection);
+    }
+    closeConnectionsForWorkspace(workspaceName) {
+        for (const [ws, connection] of this.connections) {
+            if (connection.workspaceName === workspaceName) {
+                this.handleDisconnect(connection);
+                ws.close(1001, 'Workspace stopped');
+                this.connections.delete(ws);
+            }
+        }
+    }
+}
+export function createLiveChatWebSocketServer(options) {
+    return new LiveChatWebSocketServer(options);
+}

package/dist/shared/base-websocket.js

@@ -1,4 +1,6 @@
-import { WebSocket, WebSocketServer } from 'ws';
+import { createHash } from 'crypto';
+import { WebSocket } from 'ws';
+const WEBSOCKET_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
 export function safeSend(ws, data) {
     if (ws.readyState !== WebSocket.OPEN) {
         return false;
@@ -11,14 +13,45 @@ export function safeSend(ws, data) {
         return false;
     }
 }
+function manualWebSocketUpgrade(request, socket, head, callback) {
+    const key = request.headers['sec-websocket-key'];
+    if (!key) {
+        socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    const acceptKey = createHash('sha1')
+        .update(key + WEBSOCKET_GUID)
+        .digest('base64');
+    const responseHeaders = [
+        'HTTP/1.1 101 Switching Protocols',
+        'Upgrade: websocket',
+        'Connection: Upgrade',
+        `Sec-WebSocket-Accept: ${acceptKey}`,
+    ];
+    const protocol = request.headers['sec-websocket-protocol'];
+    if (protocol) {
+        const protocols = protocol.split(',').map((p) => p.trim());
+        if (protocols.length > 0) {
+            responseHeaders.push(`Sec-WebSocket-Protocol: ${protocols[0]}`);
+        }
+    }
+    responseHeaders.push('', '');
+    socket.write(responseHeaders.join('\r\n'));
+    const wsOptions = {
+        allowSynchronousEvents: true,
+        maxPayload: 100 * 1024 * 1024,
+        skipUTF8Validation: false,
+    };
+    const ws = new WebSocket(null, undefined, wsOptions);
+    ws.setSocket(socket, head, wsOptions);
+    callback(ws);
+}
 export class BaseWebSocketServer {
-    wss;
     connections = new Map();
     isWorkspaceRunning;
     constructor(options) {
-        this.wss = new WebSocketServer({ noServer: true });
         this.isWorkspaceRunning = options.isWorkspaceRunning;
-        this.wss.on('connection', this.onConnection.bind(this));
     }
     async handleUpgrade(request, socket, head, workspaceName) {
         const running = await this.isWorkspaceRunning(workspaceName);
@@ -27,9 +60,9 @@ export class BaseWebSocketServer {
             socket.end();
             return;
         }
-        this.wss.handleUpgrade(request, socket, head, (ws) => {
+        manualWebSocketUpgrade(request, socket, head, (ws) => {
             ws.workspaceName = workspaceName;
-            this.wss.emit('connection', ws, request);
+            this.onConnection(ws);
         });
     }
     onConnection(ws) {
@@ -58,6 +91,5 @@ export class BaseWebSocketServer {
             ws.close(1001, 'Server shutting down');
         }
         this.connections.clear();
-        this.wss.close();
     }
 }

package/dist/tailscale/index.js

@@ -67,14 +67,28 @@ export async function stopTailscaleServe() {
     }
 }
 export function getTailscaleIdentity(req) {
-    const login = req.headers['tailscale-user-login'];
-    const name = req.headers['tailscale-user-name'];
-    const pic = req.headers['tailscale-user-profile-pic'];
+    let login;
+    let name;
+    let pic;
+    if ('headers' in req && req.headers instanceof Headers) {
+        login = req.headers.get('tailscale-user-login');
+        name = req.headers.get('tailscale-user-name');
+        pic = req.headers.get('tailscale-user-profile-pic');
+    }
+    else {
+        const nodeReq = req;
+        const loginHeader = nodeReq.headers['tailscale-user-login'];
+        const nameHeader = nodeReq.headers['tailscale-user-name'];
+        const picHeader = nodeReq.headers['tailscale-user-profile-pic'];
+        login = Array.isArray(loginHeader) ? loginHeader[0] : loginHeader || null;
+        name = Array.isArray(nameHeader) ? nameHeader[0] : nameHeader || null;
+        pic = Array.isArray(picHeader) ? picHeader[0] : picHeader || null;
+    }
     if (!login)
         return null;
     return {
-        email: Array.isArray(login) ? login[0] : login,
-        name: Array.isArray(name) ? name[0] : name,
-        profilePic: Array.isArray(pic) ? pic[0] : pic,
+        email: login,
+        name: name || undefined,
+        profilePic: pic || undefined,
     };
 }