@gricha/perry 0.0.1

package/dist/agent/run.js

@@ -0,0 +1,182 @@
+import { createServer } from 'http';
+import { RPCHandler } from '@orpc/server/node';
+import { loadAgentConfig, getConfigDir, ensureConfigDir } from '../config/loader';
+import { HOST_WORKSPACE_NAME } from '../shared/types';
+import { DEFAULT_AGENT_PORT } from '../shared/constants';
+import { WorkspaceManager } from '../workspace/manager';
+import { containerRunning, getContainerName } from '../docker';
+import { TerminalWebSocketServer } from '../terminal/websocket';
+import { ChatWebSocketServer } from '../chat/websocket';
+import { OpencodeWebSocketServer } from '../chat/opencode-websocket';
+import { createRouter } from './router';
+import { serveStatic } from './static';
+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) {
+    let currentConfig = config;
+    const workspaces = new WorkspaceManager(configDir, currentConfig);
+    const isWorkspaceRunning = async (name) => {
+        if (name === HOST_WORKSPACE_NAME) {
+            return currentConfig.allowHostAccess === true;
+        }
+        return containerRunning(getContainerName(name));
+    };
+    const terminalServer = new TerminalWebSocketServer({
+        getContainerName,
+        isWorkspaceRunning,
+        isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
+    });
+    const chatServer = new ChatWebSocketServer({
+        isWorkspaceRunning,
+        getConfig: () => currentConfig,
+        isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
+    });
+    const opencodeServer = new OpencodeWebSocketServer({
+        isWorkspaceRunning,
+        isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
+    });
+    const router = createRouter({
+        workspaces,
+        config: {
+            get: () => currentConfig,
+            set: (newConfig) => {
+                currentConfig = newConfig;
+                workspaces.updateConfig(newConfig);
+            },
+        },
+        configDir,
+        stateDir: configDir,
+        startTime,
+        terminalServer,
+    });
+    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;
+        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 {
+            if (pathname === '/health' && method === 'GET') {
+                sendJson(res, 200, { status: 'ok', version: pkg.version });
+                return;
+            }
+            if (pathname.startsWith('/rpc')) {
+                const { matched } = await rpcHandler.handle(req, res, {
+                    prefix: '/rpc',
+                });
+                if (matched)
+                    return;
+            }
+            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();
+        }
+    });
+    return { server, terminalServer, chatServer, opencodeServer };
+}
+async function getProcessUsingPort(port) {
+    try {
+        const proc = Bun.spawn(['lsof', '-i', `:${port}`, '-t'], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const output = await new Response(proc.stdout).text();
+        const pid = output.trim().split('\n')[0];
+        if (!pid)
+            return null;
+        const psProc = Bun.spawn(['ps', '-p', pid, '-o', 'pid=,comm=,args='], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const psOutput = await new Response(psProc.stdout).text();
+        return psOutput.trim() || `PID ${pid}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function startAgent(options = {}) {
+    const configDir = options.configDir || getConfigDir();
+    await ensureConfigDir(configDir);
+    const config = await loadAgentConfig(configDir);
+    if (options.noHostAccess || process.env.PERRY_NO_HOST_ACCESS === 'true') {
+        config.allowHostAccess = false;
+    }
+    const port = options.port || parseInt(process.env.PERRY_PORT || '', 10) || config.port || DEFAULT_AGENT_PORT;
+    console.log(`[agent] Config directory: ${configDir}`);
+    console.log(`[agent] Starting on port ${port}...`);
+    const { server, terminalServer, chatServer, opencodeServer } = createAgentServer(configDir, config);
+    server.on('error', async (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`[agent] Error: Port ${port} is already in use.`);
+            const processInfo = await getProcessUsingPort(port);
+            if (processInfo) {
+                console.error(`[agent] Process using port: ${processInfo}`);
+            }
+            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}`);
+        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`);
+    });
+    const shutdown = () => {
+        console.log('[agent] Shutting down...');
+        chatServer.close();
+        opencodeServer.close();
+        terminalServer.close();
+        server.close(() => {
+            console.log('[agent] Server closed');
+            process.exit(0);
+        });
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    return new Promise(() => { });
+}

package/dist/agent/static.js

@@ -0,0 +1,58 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+};
+function getWebDir() {
+    const distWeb = path.join(__dirname, 'web');
+    const rootDistWeb = path.resolve(__dirname, '../../dist/agent/web');
+    try {
+        require('fs').accessSync(path.join(distWeb, 'index.html'));
+        return distWeb;
+    }
+    catch {
+        return rootDistWeb;
+    }
+}
+export async function serveStatic(_req, res, pathname) {
+    const webDir = getWebDir();
+    const indexPath = path.join(webDir, 'index.html');
+    try {
+        await fs.access(indexPath);
+    }
+    catch {
+        return false;
+    }
+    const ext = path.extname(pathname).toLowerCase();
+    const isAsset = ext && ext !== '.html';
+    if (isAsset) {
+        const filePath = path.join(webDir, pathname);
+        try {
+            const content = await fs.readFile(filePath);
+            const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const content = await fs.readFile(indexPath);
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(content);
+    return true;
+}

package/dist/agent/systemd.js

@@ -0,0 +1,229 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import { DEFAULT_CONFIG_DIR } from '../shared/types';
+import { DEFAULT_AGENT_PORT } from '../shared/constants';
+const SERVICE_NAME = 'perry-agent';
+const SERVICE_DESCRIPTION = 'Perry Agent Daemon';
+function getSystemdUserDir() {
+    return path.join(os.homedir(), '.config', 'systemd', 'user');
+}
+function getServicePath() {
+    return path.join(getSystemdUserDir(), `${SERVICE_NAME}.service`);
+}
+export function generateServiceFile(options = {}) {
+    const port = options.port || DEFAULT_AGENT_PORT;
+    const configDir = options.configDir || DEFAULT_CONFIG_DIR;
+    const nodePath = process.execPath;
+    const agentPath = path.resolve(__dirname, 'index.js');
+    const envLines = [
+        `Environment=PERRY_PORT=${port}`,
+        `Environment=PERRY_CONFIG_DIR=${configDir}`,
+        `Environment=NODE_ENV=production`,
+    ];
+    if (options.noHostAccess) {
+        envLines.push(`Environment=PERRY_NO_HOST_ACCESS=true`);
+    }
+    return `[Unit]
+Description=${SERVICE_DESCRIPTION}
+After=network.target docker.service
+Wants=docker.service
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${agentPath}
+Restart=on-failure
+RestartSec=5
+${envLines.join('\n')}
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function runSystemctl(args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('systemctl', ['--user', ...args]);
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data;
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data;
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+            }
+            else {
+                const err = new Error(`systemctl exited with code ${code}: ${stderr}`);
+                reject(err);
+            }
+        });
+        proc.on('error', reject);
+    });
+}
+export async function installService(options = {}) {
+    const serviceDir = getSystemdUserDir();
+    const servicePath = getServicePath();
+    const errors = [];
+    await fs.mkdir(serviceDir, { recursive: true });
+    const serviceContent = generateServiceFile(options);
+    await fs.writeFile(servicePath, serviceContent, 'utf-8');
+    console.log(`Service file written to: ${servicePath}`);
+    try {
+        await runSystemctl(['daemon-reload']);
+        console.log('Systemd daemon reloaded');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`Failed to reload systemd daemon: ${msg}`);
+        console.error(`Error: Could not reload systemd daemon. ${msg}`);
+    }
+    try {
+        await runSystemctl(['enable', SERVICE_NAME]);
+        console.log(`Service ${SERVICE_NAME} enabled`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`Failed to enable service: ${msg}`);
+        console.error(`Error: Could not enable service. ${msg}`);
+    }
+    if (errors.length > 0) {
+        console.log('');
+        console.error('Installation failed with errors:');
+        for (const error of errors) {
+            console.error(`  - ${error}`);
+        }
+        console.log('');
+        console.log('Manual steps required:');
+        console.log('  systemctl --user daemon-reload');
+        console.log(`  systemctl --user enable ${SERVICE_NAME}`);
+        console.log(`  systemctl --user start ${SERVICE_NAME}`);
+        throw new Error('Installation failed: systemd configuration could not be completed');
+    }
+    console.log('');
+    console.log('Installation complete! To start the agent:');
+    console.log(`  systemctl --user start ${SERVICE_NAME}`);
+    console.log('');
+    console.log('To check status:');
+    console.log(`  systemctl --user status ${SERVICE_NAME}`);
+    console.log('');
+    console.log('To view logs:');
+    console.log(`  journalctl --user -u ${SERVICE_NAME} -f`);
+}
+export async function uninstallService() {
+    const servicePath = getServicePath();
+    try {
+        await runSystemctl(['stop', SERVICE_NAME]);
+        console.log(`Service ${SERVICE_NAME} stopped`);
+    }
+    catch {
+        // Service might not be running
+    }
+    try {
+        await runSystemctl(['disable', SERVICE_NAME]);
+        console.log(`Service ${SERVICE_NAME} disabled`);
+    }
+    catch {
+        // Service might not be enabled
+    }
+    try {
+        await fs.unlink(servicePath);
+        console.log(`Service file removed: ${servicePath}`);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    try {
+        await runSystemctl(['daemon-reload']);
+        console.log('Systemd daemon reloaded');
+    }
+    catch {
+        console.warn('Warning: Could not reload systemd daemon');
+    }
+    console.log('');
+    console.log('Uninstallation complete.');
+}
+export async function getServiceStatus() {
+    const servicePath = getServicePath();
+    let installed = false;
+    try {
+        await fs.access(servicePath);
+        installed = true;
+    }
+    catch {
+        installed = false;
+    }
+    let enabled = false;
+    let running = false;
+    if (installed) {
+        try {
+            await runSystemctl(['is-enabled', SERVICE_NAME]);
+            enabled = true;
+        }
+        catch {
+            enabled = false;
+        }
+        try {
+            await runSystemctl(['is-active', SERVICE_NAME]);
+            running = true;
+        }
+        catch {
+            running = false;
+        }
+    }
+    return { installed, enabled, running };
+}
+export async function showStatus() {
+    const status = await getServiceStatus();
+    console.log(`Service: ${SERVICE_NAME}`);
+    console.log(`  Installed: ${status.installed ? 'yes' : 'no'}`);
+    if (status.installed) {
+        console.log(`  Enabled: ${status.enabled ? 'yes' : 'no'}`);
+        console.log(`  Running: ${status.running ? 'yes' : 'no'}`);
+        if (status.running) {
+            console.log('');
+            console.log('Service is running. View logs with:');
+            console.log(`  journalctl --user -u ${SERVICE_NAME} -f`);
+        }
+        else {
+            console.log('');
+            console.log('Service is not running. Start with:');
+            console.log(`  systemctl --user start ${SERVICE_NAME}`);
+        }
+    }
+    else {
+        console.log('');
+        console.log('Service not installed. Install with:');
+        console.log('  perry agent install');
+    }
+}
+export async function showLogs(options = {}) {
+    const status = await getServiceStatus();
+    if (!status.installed) {
+        console.error('Agent service is not installed.');
+        console.error('Install with: perry agent install');
+        process.exit(1);
+    }
+    const args = ['--user', '-u', SERVICE_NAME, '--no-pager'];
+    if (options.follow) {
+        args.push('-f');
+    }
+    if (options.lines) {
+        args.push('-n', String(options.lines));
+    }
+    const proc = spawn('journalctl', args, {
+        stdio: 'inherit',
+    });
+    proc.on('error', (err) => {
+        console.error(`Failed to run journalctl: ${err.message}`);
+        process.exit(1);
+    });
+    proc.on('close', (code) => {
+        process.exit(code || 0);
+    });
+}