@gricha/perry 0.2.1 → 0.2.3

package/dist/agent/run.js

@@ -1,7 +1,7 @@
 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 { HOST_WORKSPACE_NAME } from '../shared/client-types';
 import { DEFAULT_AGENT_PORT } from '../shared/constants';
 import { WorkspaceManager } from '../workspace/manager';
 import { containerRunning, getContainerName } from '../docker';
@@ -13,17 +13,36 @@ import { createRouter } from './router';
 import { serveStatic } 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) {
+function createAgentServer(configDir, config, tailscale) {
     let currentConfig = config;
     const workspaces = new WorkspaceManager(configDir, currentConfig);
     const sessionsCache = new SessionsCacheManager(configDir);
     const modelCache = new ModelCacheManager(configDir);
+    const syncAllRunning = async () => {
+        const allWorkspaces = await workspaces.list();
+        const running = allWorkspaces.filter((ws) => ws.status === 'running');
+        for (const ws of running) {
+            try {
+                await workspaces.sync(ws.name);
+                console.log(`[sync] Synced workspace: ${ws.name}`);
+            }
+            catch (err) {
+                console.error(`[sync] Failed to sync ${ws.name}:`, err);
+            }
+        }
+    };
+    const fileWatcher = new FileWatcher({
+        config: currentConfig,
+        syncCallback: syncAllRunning,
+    });
     const isWorkspaceRunning = async (name) => {
         if (name === HOST_WORKSPACE_NAME) {
             return currentConfig.allowHostAccess === true;
@@ -45,6 +64,11 @@ function createAgentServer(configDir, config) {
         isHostAccessAllowed: () => currentConfig.allowHostAccess === true,
         getConfig: () => currentConfig,
     });
+    const triggerAutoSync = () => {
+        syncAllRunning().catch((err) => {
+            console.error('[sync] Auto-sync failed:', err);
+        });
+    };
     const router = createRouter({
         workspaces,
         config: {
@@ -52,6 +76,7 @@ function createAgentServer(configDir, config) {
             set: (newConfig) => {
                 currentConfig = newConfig;
                 workspaces.updateConfig(newConfig);
+                fileWatcher.updateConfig(newConfig);
             },
         },
         configDir,
@@ -60,12 +85,15 @@ function createAgentServer(configDir, config) {
         terminalServer,
         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');
@@ -76,7 +104,11 @@ function createAgentServer(configDir, config) {
         }
         try {
             if (pathname === '/health' && method === 'GET') {
-                sendJson(res, 200, { status: 'ok', version: pkg.version });
+                const response = { status: 'ok', version: pkg.version };
+                if (identity) {
+                    response.user = identity.email;
+                }
+                sendJson(res, 200, response);
                 return;
             }
             if (pathname.startsWith('/rpc')) {
@@ -118,7 +150,7 @@ function createAgentServer(configDir, config) {
             socket.destroy();
         }
     });
-    return { server, terminalServer, chatServer, opencodeServer };
+    return { server, terminalServer, chatServer, opencodeServer, fileWatcher };
 }
 async function getProcessUsingPort(port) {
     try {
@@ -151,7 +183,38 @@ export async function startAgent(options = {}) {
     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);
+    const tailscale = await getTailscaleStatus();
+    let tailscaleServeActive = false;
+    if (tailscale.running && tailscale.dnsName) {
+        console.log(`[agent] Tailscale detected: ${tailscale.dnsName}`);
+        if (!tailscale.httpsEnabled) {
+            console.log(`[agent] Tailscale HTTPS not enabled in tailnet, skipping Serve`);
+        }
+        else {
+            const result = await startTailscaleServe(port);
+            if (result.success) {
+                tailscaleServeActive = true;
+                console.log(`[agent] Tailscale Serve enabled`);
+            }
+            else if (result.error === 'permission_denied') {
+                console.log(`[agent] Tailscale Serve requires operator permissions`);
+                console.log(`[agent] To enable: ${result.message}`);
+                console.log(`[agent] Continuing without HTTPS...`);
+            }
+            else {
+                console.log(`[agent] Tailscale Serve failed: ${result.message || 'unknown error'}`);
+            }
+        }
+    }
+    const tailscaleInfo = tailscale.running && tailscale.dnsName
+        ? {
+            running: true,
+            dnsName: tailscale.dnsName,
+            serveActive: tailscaleServeActive,
+            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') {
             console.error(`[agent] Error: Port ${port} is already in use.`);
@@ -169,14 +232,26 @@ export async function startAgent(options = {}) {
     });
     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}`);
+            }
+        }
         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();
     });
-    const shutdown = () => {
+    const shutdown = async () => {
         console.log('[agent] Shutting down...');
+        fileWatcher.stop();
+        if (tailscaleServeActive) {
+            console.log('[agent] Stopping Tailscale Serve...');
+            await stopTailscaleServe();
+        }
         chatServer.close();
         opencodeServer.close();
         terminalServer.close();