@gricha/perry 0.2.6 → 0.3.1

package/dist/agent/router.js

@@ -12,6 +12,7 @@ import { parseClaudeSessionContent } from '../sessions/parser';
 import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, deleteSession as deleteSessionFromProvider, searchSessions as searchSessionsInContainer, } from '../sessions/agents';
 import { discoverClaudeCodeModels, discoverHostOpencodeModels, discoverContainerOpencodeModels, } from '../models/discovery';
 import { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession, } from '../sessions/agents/opencode-storage';
+import { sessionManager } from '../session-manager';
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
 const WorkspacePortsSchema = z.object({
     ssh: z.number(),
@@ -965,6 +966,122 @@ export function createRouter(ctx) {
         }
         return { models };
     });
+    const LiveAgentTypeSchema = z.enum(['claude', 'opencode', 'codex']);
+    const listLiveSessions = os
+        .input(z.object({
+        workspaceName: z.string().optional(),
+    }))
+        .handler(async ({ input }) => {
+        const sessions = sessionManager.listActiveSessions(input.workspaceName);
+        return sessions.map((s) => ({
+            ...s,
+            startedAt: s.startedAt.toISOString(),
+            lastActivity: s.lastActivity.toISOString(),
+        }));
+    });
+    const getLiveSession = os
+        .input(z.object({
+        sessionId: z.string(),
+    }))
+        .handler(async ({ input }) => {
+        const session = sessionManager.getSession(input.sessionId);
+        if (!session) {
+            throw new ORPCError('NOT_FOUND', { message: 'Live session not found' });
+        }
+        return {
+            ...session,
+            startedAt: session.startedAt.toISOString(),
+            lastActivity: session.lastActivity.toISOString(),
+        };
+    });
+    const getLiveSessionStatus = os
+        .input(z.object({
+        sessionId: z.string(),
+    }))
+        .handler(async ({ input }) => {
+        const status = sessionManager.getSessionStatus(input.sessionId);
+        if (!status) {
+            throw new ORPCError('NOT_FOUND', { message: 'Live session not found' });
+        }
+        return { status };
+    });
+    const startLiveSession = os
+        .input(z.object({
+        workspaceName: z.string(),
+        agentType: LiveAgentTypeSchema,
+        sessionId: z.string().optional(),
+        agentSessionId: z.string().optional(),
+        model: z.string().optional(),
+        projectPath: z.string().optional(),
+    }))
+        .handler(async ({ input }) => {
+        if (input.workspaceName !== HOST_WORKSPACE_NAME) {
+            const workspace = await ctx.workspaces.get(input.workspaceName);
+            if (!workspace) {
+                throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
+            }
+            if (workspace.status !== 'running') {
+                throw new ORPCError('PRECONDITION_FAILED', { message: 'Workspace is not running' });
+            }
+        }
+        else {
+            const config = ctx.config.get();
+            if (!config.allowHostAccess) {
+                throw new ORPCError('PRECONDITION_FAILED', { message: 'Host access is disabled' });
+            }
+        }
+        const sessionId = await sessionManager.startSession({
+            workspaceName: input.workspaceName,
+            agentType: input.agentType,
+            sessionId: input.sessionId,
+            agentSessionId: input.agentSessionId,
+            model: input.model,
+            projectPath: input.projectPath,
+        });
+        return { sessionId };
+    });
+    const sendLiveMessage = os
+        .input(z.object({
+        sessionId: z.string(),
+        message: z.string(),
+    }))
+        .handler(async ({ input }) => {
+        const session = sessionManager.getSession(input.sessionId);
+        if (!session) {
+            throw new ORPCError('NOT_FOUND', { message: 'Live session not found' });
+        }
+        await sessionManager.sendMessage(input.sessionId, input.message);
+        return { success: true };
+    });
+    const interruptLiveSession = os
+        .input(z.object({
+        sessionId: z.string(),
+    }))
+        .handler(async ({ input }) => {
+        const session = sessionManager.getSession(input.sessionId);
+        if (!session) {
+            throw new ORPCError('NOT_FOUND', { message: 'Live session not found' });
+        }
+        await sessionManager.interrupt(input.sessionId);
+        return { success: true };
+    });
+    const disposeLiveSession = os
+        .input(z.object({
+        sessionId: z.string(),
+    }))
+        .handler(async ({ input }) => {
+        await sessionManager.disposeSession(input.sessionId);
+        return { success: true };
+    });
+    const getLiveSessionMessages = os
+        .input(z.object({
+        sessionId: z.string(),
+        sinceId: z.number().optional(),
+    }))
+        .handler(async ({ input }) => {
+        const messages = sessionManager.getBufferedMessages(input.sessionId, input.sinceId);
+        return { messages };
+    });
     return {
         workspaces: {
             list: listWorkspaces,
@@ -991,6 +1108,16 @@ export function createRouter(ctx) {
             delete: deleteSession,
             search: searchSessions,
         },
+        live: {
+            list: listLiveSessions,
+            get: getLiveSession,
+            getStatus: getLiveSessionStatus,
+            start: startLiveSession,
+            sendMessage: sendLiveMessage,
+            interrupt: interruptLiveSession,
+            dispose: disposeLiveSession,
+            getMessages: getLiveSessionMessages,
+        },
         models: {
             list: listModels,
         },

package/dist/agent/run.js

@@ -1,27 +1,21 @@
-import { createServer } from 'http';
-import { RPCHandler } from '@orpc/server/node';
+import { RPCHandler } from '@orpc/server/fetch';
 import { loadAgentConfig, getConfigDir, ensureConfigDir } from '../config/loader';
 import { HOST_WORKSPACE_NAME } from '../shared/client-types';
 import { DEFAULT_AGENT_PORT } from '../shared/constants';
 import { WorkspaceManager } from '../workspace/manager';
 import { containerRunning, getContainerName } from '../docker';
 import { startEagerImagePull, stopEagerImagePull } from '../docker/eager-pull';
-import { TerminalWebSocketServer } from '../terminal/websocket';
-import { ChatWebSocketServer } from '../chat/websocket';
-import { OpencodeWebSocketServer } from '../chat/opencode-websocket';
+import { TerminalHandler } from '../terminal/bun-handler';
+import { LiveChatHandler } from '../session-manager/bun-handler';
 import { createRouter } from './router';
-import { serveStatic } from './static';
+import { serveStaticBun } from './static';
 import { SessionsCacheManager } from '../sessions/cache';
 import { ModelCacheManager } from '../models/cache';
 import { FileWatcher } from './file-watcher';
 import { getTailscaleStatus, getTailscaleIdentity, startTailscaleServe, stopTailscaleServe, } from '../tailscale';
 import pkg from '../../package.json';
 const startTime = Date.now();
-function sendJson(res, status, data) {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(data));
-}
-function createAgentServer(configDir, config, tailscale) {
+function createAgentServer(configDir, config, port, tailscale) {
     let currentConfig = config;
     const workspaces = new WorkspaceManager(configDir, currentConfig);
     const sessionsCache = new SessionsCacheManager(configDir);
@@ -52,21 +46,21 @@ function createAgentServer(configDir, config, tailscale) {
     const getPreferredShell = () => {
         return currentConfig.terminal?.preferredShell || process.env.SHELL;
     };
-    const terminalServer = new TerminalWebSocketServer({
+    const terminalHandler = new TerminalHandler({
         getContainerName,
         isWorkspaceRunning,
         isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
         getPreferredShell,
     });
-    const chatServer = new ChatWebSocketServer({
+    const liveClaudeHandler = new LiveChatHandler({
         isWorkspaceRunning,
-        getConfig: () => currentConfig,
         isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
+        agentType: 'claude',
     });
-    const opencodeServer = new OpencodeWebSocketServer({
+    const liveOpencodeHandler = new LiveChatHandler({
         isWorkspaceRunning,
         isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
-        getConfig: () => currentConfig,
+        agentType: 'opencode',
     });
     const triggerAutoSync = () => {
         syncAllRunning().catch((err) => {
@@ -86,75 +80,133 @@ function createAgentServer(configDir, config, tailscale) {
         configDir,
         stateDir: configDir,
         startTime,
-        terminalServer,
+        terminalServer: terminalHandler,
         sessionsCache,
         modelCache,
         tailscale,
         triggerAutoSync,
     });
     const rpcHandler = new RPCHandler(router);
-    const server = createServer(async (req, res) => {
-        const url = new URL(req.url || '/', 'http://localhost');
-        const method = req.method;
-        const pathname = url.pathname;
-        const identity = getTailscaleIdentity(req);
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-        if (method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        try {
+    const server = Bun.serve({
+        port,
+        hostname: '::',
+        async fetch(req, server) {
+            const url = new URL(req.url);
+            const pathname = url.pathname;
+            const method = req.method;
+            const corsHeaders = {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type',
+            };
+            if (method === 'OPTIONS') {
+                return new Response(null, { status: 204, headers: corsHeaders });
+            }
+            const terminalMatch = pathname.match(/^\/rpc\/terminal\/([^/]+)$/);
+            const liveClaudeMatch = pathname.match(/^\/rpc\/live\/claude\/([^/]+)$/);
+            const liveOpencodeMatch = pathname.match(/^\/rpc\/live\/opencode\/([^/]+)$/);
+            if (terminalMatch || liveClaudeMatch || liveOpencodeMatch) {
+                let type;
+                let workspaceName;
+                if (terminalMatch) {
+                    type = 'terminal';
+                    workspaceName = decodeURIComponent(terminalMatch[1]);
+                }
+                else if (liveClaudeMatch) {
+                    type = 'live-claude';
+                    workspaceName = decodeURIComponent(liveClaudeMatch[1]);
+                }
+                else {
+                    type = 'live-opencode';
+                    workspaceName = decodeURIComponent(liveOpencodeMatch[1]);
+                }
+                const running = await isWorkspaceRunning(workspaceName);
+                if (!running) {
+                    return new Response('Not Found', { status: 404 });
+                }
+                const upgraded = server.upgrade(req, {
+                    data: { type, workspaceName },
+                });
+                if (upgraded) {
+                    return undefined;
+                }
+                return new Response('WebSocket upgrade failed', { status: 400 });
+            }
             if (pathname === '/health' && method === 'GET') {
+                const identity = getTailscaleIdentity(req);
                 const response = { status: 'ok', version: pkg.version };
                 if (identity) {
                     response.user = identity.email;
                 }
-                sendJson(res, 200, response);
-                return;
+                return Response.json(response, { headers: corsHeaders });
             }
             if (pathname.startsWith('/rpc')) {
-                const { matched } = await rpcHandler.handle(req, res, {
+                const { matched, response } = await rpcHandler.handle(req, {
                     prefix: '/rpc',
                 });
-                if (matched)
-                    return;
+                if (matched && response) {
+                    const newHeaders = new Headers(response.headers);
+                    Object.entries(corsHeaders).forEach(([k, v]) => newHeaders.set(k, v));
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: newHeaders,
+                    });
+                }
             }
-            const served = await serveStatic(req, res, pathname);
-            if (served)
-                return;
-            sendJson(res, 404, { error: 'Not found' });
-        }
-        catch (err) {
-            console.error('Request error:', err);
-            sendJson(res, 500, { error: 'Internal server error' });
-        }
-    });
-    server.on('upgrade', async (request, socket, head) => {
-        const url = new URL(request.url || '/', 'http://localhost');
-        const terminalMatch = url.pathname.match(/^\/rpc\/terminal\/([^/]+)$/);
-        const chatMatch = url.pathname.match(/^\/rpc\/chat\/([^/]+)$/);
-        const opencodeMatch = url.pathname.match(/^\/rpc\/opencode\/([^/]+)$/);
-        if (terminalMatch) {
-            const workspaceName = decodeURIComponent(terminalMatch[1]);
-            await terminalServer.handleUpgrade(request, socket, head, workspaceName);
-        }
-        else if (chatMatch) {
-            const workspaceName = decodeURIComponent(chatMatch[1]);
-            await chatServer.handleUpgrade(request, socket, head, workspaceName);
-        }
-        else if (opencodeMatch) {
-            const workspaceName = decodeURIComponent(opencodeMatch[1]);
-            await opencodeServer.handleUpgrade(request, socket, head, workspaceName);
-        }
-        else {
-            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
-            socket.destroy();
-        }
+            const staticResponse = await serveStaticBun(pathname);
+            if (staticResponse) {
+                return staticResponse;
+            }
+            return Response.json({ error: 'Not found' }, { status: 404, headers: corsHeaders });
+        },
+        websocket: {
+            open(ws) {
+                const { type, workspaceName } = ws.data;
+                if (type === 'terminal') {
+                    terminalHandler.handleOpen(ws, workspaceName);
+                }
+                else if (type === 'live-claude') {
+                    liveClaudeHandler.handleOpen(ws, workspaceName);
+                }
+                else if (type === 'live-opencode') {
+                    liveOpencodeHandler.handleOpen(ws, workspaceName);
+                }
+            },
+            message(ws, message) {
+                const { type } = ws.data;
+                const data = typeof message === 'string' ? message : message.toString();
+                if (type === 'terminal') {
+                    terminalHandler.handleMessage(ws, data);
+                }
+                else if (type === 'live-claude') {
+                    liveClaudeHandler.handleMessage(ws, data);
+                }
+                else if (type === 'live-opencode') {
+                    liveOpencodeHandler.handleMessage(ws, data);
+                }
+            },
+            close(ws, code, reason) {
+                const { type } = ws.data;
+                if (type === 'terminal') {
+                    terminalHandler.handleClose(ws, code, reason);
+                }
+                else if (type === 'live-claude') {
+                    liveClaudeHandler.handleClose(ws, code, reason);
+                }
+                else if (type === 'live-opencode') {
+                    liveOpencodeHandler.handleClose(ws, code, reason);
+                }
+            },
+        },
     });
-    return { server, terminalServer, chatServer, opencodeServer, fileWatcher };
+    return {
+        server,
+        terminalHandler,
+        liveClaudeHandler,
+        liveOpencodeHandler,
+        fileWatcher,
+    };
 }
 async function getProcessUsingPort(port) {
     try {
@@ -218,9 +270,22 @@ export async function startAgent(options = {}) {
             httpsUrl: tailscaleServeActive ? `https://${tailscale.dnsName}` : undefined,
         }
         : undefined;
-    const { server, terminalServer, chatServer, opencodeServer, fileWatcher } = createAgentServer(configDir, config, tailscaleInfo);
-    server.on('error', async (err) => {
-        if (err.code === 'EADDRINUSE') {
+    let server;
+    let fileWatcher;
+    let terminalHandler;
+    let liveClaudeHandler;
+    let liveOpencodeHandler;
+    try {
+        const result = createAgentServer(configDir, config, port, tailscaleInfo);
+        server = result.server;
+        fileWatcher = result.fileWatcher;
+        terminalHandler = result.terminalHandler;
+        liveClaudeHandler = result.liveClaudeHandler;
+        liveOpencodeHandler = result.liveOpencodeHandler;
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === 'EADDRINUSE') {
             console.error(`[agent] Error: Port ${port} is already in use.`);
             const processInfo = await getProcessUsingPort(port);
             if (processInfo) {
@@ -229,26 +294,21 @@ export async function startAgent(options = {}) {
             console.error(`[agent] Try using a different port with: perry agent run --port <port>`);
             process.exit(1);
         }
-        else {
-            console.error(`[agent] Server error: ${err.message}`);
-            process.exit(1);
-        }
-    });
-    server.listen(port, '::', () => {
-        console.log(`[agent] Agent running at http://localhost:${port}`);
-        if (tailscale.running && tailscale.dnsName) {
-            const shortName = tailscale.dnsName.split('.')[0];
-            console.log(`[agent] Tailnet: http://${shortName}:${port}`);
-            if (tailscaleServeActive) {
-                console.log(`[agent] Tailnet HTTPS: https://${tailscale.dnsName}`);
-            }
+        throw err;
+    }
+    console.log(`[agent] Agent running at http://localhost:${port}`);
+    if (tailscale.running && tailscale.dnsName) {
+        const shortName = tailscale.dnsName.split('.')[0];
+        console.log(`[agent] Tailnet: http://${shortName}:${port}`);
+        if (tailscaleServeActive) {
+            console.log(`[agent] Tailnet HTTPS: https://${tailscale.dnsName}`);
         }
-        console.log(`[agent] oRPC endpoint: http://localhost:${port}/rpc`);
-        console.log(`[agent] WebSocket terminal: ws://localhost:${port}/rpc/terminal/:name`);
-        console.log(`[agent] WebSocket chat (Claude): ws://localhost:${port}/rpc/chat/:name`);
-        console.log(`[agent] WebSocket chat (OpenCode): ws://localhost:${port}/rpc/opencode/:name`);
-        startEagerImagePull();
-    });
+    }
+    console.log(`[agent] oRPC endpoint: http://localhost:${port}/rpc`);
+    console.log(`[agent] WebSocket terminal: ws://localhost:${port}/rpc/terminal/:name`);
+    console.log(`[agent] WebSocket chat (Claude): ws://localhost:${port}/rpc/live/claude/:name`);
+    console.log(`[agent] WebSocket chat (OpenCode): ws://localhost:${port}/rpc/live/opencode/:name`);
+    startEagerImagePull();
     let isShuttingDown = false;
     const shutdown = async () => {
         if (isShuttingDown) {
@@ -268,15 +328,13 @@ export async function startAgent(options = {}) {
             console.log('[agent] Stopping Tailscale Serve...');
             await stopTailscaleServe();
         }
-        chatServer.close();
-        opencodeServer.close();
-        terminalServer.close();
-        server.closeAllConnections();
-        server.close(() => {
-            clearTimeout(forceExitTimeout);
-            console.log('[agent] Server closed');
-            process.exit(0);
-        });
+        liveClaudeHandler.close();
+        liveOpencodeHandler.close();
+        terminalHandler.close();
+        server.stop();
+        clearTimeout(forceExitTimeout);
+        console.log('[agent] Server closed');
+        process.exit(0);
     };
     process.on('SIGTERM', shutdown);
     process.on('SIGINT', shutdown);

package/dist/agent/static.js

@@ -65,3 +65,35 @@ export async function serveStatic(_req, res, pathname) {
     res.end(content);
     return true;
 }
+export async function serveStaticBun(pathname) {
+    const webDir = getWebDir();
+    const indexPath = path.join(webDir, 'index.html');
+    try {
+        await fs.access(indexPath);
+    }
+    catch {
+        return null;
+    }
+    const ext = path.extname(pathname).toLowerCase();
+    const isAsset = ext && ext !== '.html';
+    if (isAsset) {
+        const filePath = path.join(webDir, pathname);
+        try {
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+                const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                return new Response(file, {
+                    headers: { 'Content-Type': contentType },
+                });
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    const file = Bun.file(indexPath);
+    return new Response(file, {
+        headers: { 'Content-Type': 'text/html' },
+    });
+}