agent-window 1.0.0 → 1.0.2

package/src/api/routes/instances.js

@@ -0,0 +1,252 @@
+/**
+ * Instance Routes
+ *
+ * REST API endpoints for instance management.
+ * - GET /api/instances - List all instances
+ * - GET /api/instances/:name - Get instance details
+ * - POST /api/instances - Add new instance
+ * - DELETE /api/instances/:name - Remove instance
+ * - GET /api/instances/:name/status - Get instance status
+ */
+
+import {
+  listInstances,
+  getInstance,
+  addInstance,
+  removeInstance,
+  updateInstance
+} from '../../core/instance/manager.js';
+import {
+  getStatus,
+  getLogs
+} from '../../core/instance/pm2-bridge.js';
+import { existsSync } from 'fs';
+
+/**
+ * Register instance routes
+ */
+export async function registerInstanceRoutes(fastify) {
+
+  /**
+   * GET /api/instances
+   * List all registered instances
+   */
+  fastify.get('/api/instances', {
+    schema: {
+      description: 'List all instances',
+      tags: ['instances'],
+      response: {
+        200: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              displayName: { type: 'string' },
+              projectPath: { type: 'string' },
+              pluginPath: { type: 'string' },
+              enabled: { type: 'boolean' },
+              tags: { type: 'array', items: { type: 'string' } },
+              addedAt: { type: 'string' }
+            }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const instances = await listInstances();
+      return instances;
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to list instances',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /api/instances/:name
+   * Get specific instance details
+   */
+  fastify.get('/api/instances/:name', {
+    schema: {
+      description: 'Get instance details',
+      params: {
+        name: { type: 'string' }
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            displayName: { type: 'string' },
+            projectPath: { type: 'string' },
+            configPath: { type: 'string' },
+            enabled: { type: 'boolean' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const instance = await getInstance(name);
+
+      if (!instance) {
+        return reply.code(404).send({
+          error: 'Instance not found',
+          name
+        });
+      }
+
+      return instance;
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to get instance',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/instances
+   * Add a new instance
+   */
+  fastify.post('/api/instances', {
+    schema: {
+      description: 'Add new instance',
+      body: {
+        type: 'object',
+        required: ['name', 'projectPath'],
+        properties: {
+          name: { type: 'string' },
+          projectPath: { type: 'string' },
+          displayName: { type: 'string' },
+          tags: { type: 'array', items: { type: 'string' } },
+          configPath: { type: 'string' }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name, projectPath, displayName, tags, configPath } = request.body;
+
+      // Validate project path exists
+      if (!existsSync(projectPath)) {
+        return reply.code(400).send({
+          error: 'Project path does not exist',
+          path: projectPath
+        });
+      }
+
+      const result = await addInstance(name, projectPath, {
+        displayName,
+        tags,
+        configPath
+      });
+
+      if (!result.success) {
+        return reply.code(400).send({
+          error: result.error,
+          validation: result.validation
+        });
+      }
+
+      reply.code(201).send(result.instance);
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to add instance',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * DELETE /api/instances/:name
+   * Remove an instance
+   */
+  fastify.delete('/api/instances/:name', {
+    schema: {
+      description: 'Remove instance',
+      params: {
+        name: { type: 'string' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const result = await removeInstance(name);
+
+      if (!result.success) {
+        return reply.code(404).send({
+          error: result.error,
+          name
+        });
+      }
+
+      return { message: 'Instance removed', name };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to remove instance',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /api/instances/:name/status
+   * Get instance runtime status
+   */
+  fastify.get('/api/instances/:name/status', {
+    schema: {
+      description: 'Get instance status',
+      params: {
+        name: { type: 'string' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const status = await getStatus(name);
+      return status;
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to get status',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /api/instances/:name/logs
+   * Get instance logs (non-streaming)
+   */
+  fastify.get('/api/instances/:name/logs', {
+    schema: {
+      description: 'Get instance logs',
+      params: {
+        name: { type: 'string' }
+      },
+      querystring: {
+        lines: { type: 'number', default: 100 },
+        logType: { type: 'string', enum: ['all', 'out', 'err'], default: 'all' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const { lines = 100, logType = 'all' } = request.query;
+
+      const logs = await getLogs(name, { lines, type: logType });
+      return { logs };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to get logs',
+        message: error.message
+      });
+    }
+  });
+
+  fastify.log.info('Instance routes registered');
+}

package/src/api/routes/operations.js

@@ -0,0 +1,118 @@
+/**
+ * Operation Routes
+ *
+ * REST API endpoints for instance operations.
+ * - POST /api/instances/:name/start - Start instance
+ * - POST /api/instances/:name/stop - Stop instance
+ * - POST /api/instances/:name/restart - Restart instance
+ */
+
+import {
+  startProcess,
+  stopProcess,
+  restartProcess
+} from '../../core/instance/pm2-bridge.js';
+
+/**
+ * Register operation routes
+ */
+export async function registerOperationRoutes(fastify) {
+
+  /**
+   * POST /api/instances/:name/start
+   * Start an instance
+   */
+  fastify.post('/api/instances/:name/start', {
+    schema: {
+      description: 'Start instance',
+      params: {
+        name: { type: 'string' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const result = await startProcess(name);
+
+      if (!result.success) {
+        return reply.code(400).send({
+          error: result.error,
+          name
+        });
+      }
+
+      return { message: 'Instance started', name };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to start instance',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/instances/:name/stop
+   * Stop an instance
+   */
+  fastify.post('/api/instances/:name/stop', {
+    schema: {
+      description: 'Stop instance',
+      params: {
+        name: { type: 'string' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const result = await stopProcess(name);
+
+      if (!result.success) {
+        return reply.code(400).send({
+          error: result.error,
+          name
+        });
+      }
+
+      return { message: 'Instance stopped', name };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to stop instance',
+        message: error.message
+      });
+    }
+  });
+
+  /**
+   * POST /api/instances/:name/restart
+   * Restart an instance
+   */
+  fastify.post('/api/instances/:name/restart', {
+    schema: {
+      description: 'Restart instance',
+      params: {
+        name: { type: 'string' }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name } = request.params;
+      const result = await restartProcess(name);
+
+      if (!result.success) {
+        return reply.code(400).send({
+          error: result.error,
+          name
+        });
+      }
+
+      return { message: 'Instance restarted', name };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to restart instance',
+        message: error.message
+      });
+    }
+  });
+
+  fastify.log.info('Operation routes registered');
+}

package/src/api/routes/system.js

@@ -0,0 +1,42 @@
+/**
+ * System Routes
+ *
+ * REST API endpoints for system information.
+ * - GET /api/system/info - System information
+ * - GET /api/system/stats - System statistics
+ */
+
+import { platform } from 'os';
+import { getPackageVersion } from '../server.js';
+
+/**
+ * Register system routes
+ */
+export async function registerSystemRoutes(fastify) {
+
+  /**
+   * GET /api/system/info
+   * Get system information
+   */
+  fastify.get('/api/system/info', async () => ({
+    platform: platform(),
+    nodeVersion: process.version,
+    agentWindow: {
+      version: getPackageVersion(),
+      home: process.env.AGENT_WINDOW_HOME || `${process.env.HOME}/.agent-window`
+    },
+    uptime: process.uptime()
+  }));
+
+  /**
+   * GET /api/system/stats
+   * Get system statistics
+   */
+  fastify.get('/api/system/stats', async () => ({
+    memory: process.memoryUsage(),
+    uptime: process.uptime(),
+    cpu: process.cpuUsage()
+  }));
+
+  fastify.log.info('System routes registered');
+}

package/src/api/server.js

@@ -0,0 +1,147 @@
+/**
+ * API Server
+ *
+ * Fastify-based REST API and WebSocket server for AgentWindow Web UI.
+ * Local-only access (localhost) with no authentication required.
+ */
+
+import Fastify from 'fastify';
+import fastifyStatic from '@fastify/static';
+import fastifyWebSocket from '@fastify/websocket';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Routes
+import { registerRoutes } from './routes/index.js';
+import { registerWebSocket } from './websocket/index.js';
+
+// Server configuration
+const DEFAULT_PORT = 3721;
+const HOST = '127.0.0.1'; // Localhost only
+
+/**
+ * Create and configure Fastify server
+ */
+export function createServer(options = {}) {
+  const { logger = true, port = DEFAULT_PORT } = options;
+
+  const fastify = Fastify({
+    logger: logger ? {
+      transport: {
+        target: 'pino-pretty',
+        options: { colorize: true }
+      }
+    } : false,
+    ignoreTrailingSlash: true
+  });
+
+  // Register WebSocket support
+  fastify.register(fastifyWebSocket);
+
+  // CORS for local development
+  fastify.register(async function (fastify) {
+    fastify.addHook('onRequest', async (request, reply) => {
+      // Allow only local access
+      const ip = request.ip;
+      const isLocal = ip === '127.0.0.1' || ip === '::1' || ip === 'localhost';
+
+      if (!isLocal) {
+        reply.code(403).send({ error: 'Access denied - local only' });
+        return reply;
+      }
+
+      // Add CORS headers for local development
+      reply.header('Access-Control-Allow-Origin', '*');
+      reply.header('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
+      reply.header('Access-Control-Allow-Headers', 'Content-Type,Authorization');
+    });
+  });
+
+  // Health check
+  fastify.get('/api/health', async () => ({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    version: getPackageVersion()
+  }));
+
+  // Register API routes
+  registerRoutes(fastify);
+
+  // Register WebSocket routes
+  registerWebSocket(fastify);
+
+  // Serve static files (frontend build)
+  const distPath = join(process.cwd(), 'web', 'dist');
+  if (existsSync(distPath)) {
+    fastify.register(fastifyStatic, {
+      root: distPath,
+      prefix: '/'
+    });
+
+    // SPA fallback - serve index.html for non-API routes
+    fastify.setNotFoundHandler(async (request, reply) => {
+      if (request.url.startsWith('/api/') || request.url.startsWith('/ws/')) {
+        reply.code(404).send({ error: 'Not found' });
+      } else {
+        reply.sendFile('index.html');
+      }
+    });
+  }
+
+  // Graceful shutdown
+  const gracefulShutdown = async (signal) => {
+    fastify.log.info(`Received ${signal}, shutting down gracefully...`);
+    await fastify.close();
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+  return { fastify, port, host: HOST };
+}
+
+/**
+ * Get package version
+ */
+export function getPackageVersion() {
+  try {
+    const pkgPath = join(process.cwd(), 'package.json');
+    const pkg = require(pkgPath);
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Start the server
+ */
+export async function startServer(options = {}) {
+  const { fastify, port, host } = createServer(options);
+
+  try {
+    const address = await fastify.listen({ port, host });
+    fastify.log.info(`🚀 AgentWindow UI server running at http://${address}`);
+
+    // Open browser (optional)
+    if (options.open !== false) {
+      const { default: open } = await import('open');
+      await open(`http://${host}:${port}`).catch(() => {
+        fastify.log.warn('Could not open browser automatically');
+      });
+    }
+
+    return fastify;
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+}
+
+// CLI entry point
+export default { startServer, createServer };

package/src/api/websocket/index.js

@@ -0,0 +1,16 @@
+/**
+ * WebSocket Routes Registry
+ *
+ * Registers all WebSocket routes for real-time features.
+ */
+
+import { registerLogStream } from './logs.js';
+
+/**
+ * Register all WebSocket routes
+ */
+export async function registerWebSocket(fastify) {
+  await registerLogStream(fastify);
+
+  fastify.log.info('All WebSocket routes registered');
+}

package/src/api/websocket/logs.js

@@ -0,0 +1,127 @@
+/**
+ * Log Stream WebSocket
+ *
+ * Real-time log streaming from PM2 processes.
+ * WS /ws/logs/:name - Stream logs for specific instance
+ */
+
+import { spawn } from 'child_process';
+import { isWindows, isWSLAvailable } from '../../core/platform/detector.js';
+
+// Active log streams by instance name
+const activeStreams = new Map();
+
+/**
+ * Register log streaming WebSocket route
+ */
+export async function registerLogStream(fastify) {
+
+  /**
+   * WebSocket /ws/logs/:name
+   * Stream logs for a specific instance
+   */
+  fastify.register(async function (fastify) {
+    fastify.get('/ws/logs/:name', { websocket: true }, (connection, req) => {
+      const { name } = req.params;
+
+      // Close existing stream for this instance if any
+      if (activeStreams.has(name)) {
+        const existing = activeStreams.get(name);
+        existing.kill();
+        activeStreams.delete(name);
+      }
+
+      connection.socket.on('open', () => {
+        fastify.log.info(`Log stream started for: ${name}`);
+      });
+
+      // Send initial connection message
+      connection.socket.send(JSON.stringify({
+        type: 'connected',
+        instance: name,
+        timestamp: new Date().toISOString()
+      }));
+
+      // Start PM2 log stream
+      let pm2Cmd = 'pm2';
+      let pm2Args = ['logs', name, '--lines', '50', '--raw', '--nostream'];
+
+      // On Windows, use WSL if available
+      if (isWindows()) {
+        isWSLAvailable().then(wsl => {
+          if (wsl) {
+            pm2Cmd = 'wsl.exe';
+            pm2Args = ['pm2', ...pm2Args];
+            startLogStream();
+          } else {
+            startLogStream();
+          }
+        }).catch(() => startLogStream());
+      } else {
+        startLogStream();
+      }
+
+      function startLogStream() {
+        const logProcess = spawn(pm2Cmd, pm2Args, {
+          windowsHide: true
+        });
+
+        activeStreams.set(name, logProcess);
+
+        logProcess.stdout.on('data', (data) => {
+          try {
+            const lines = data.toString().split('\n').filter(l => l.trim());
+            for (const line of lines) {
+              connection.socket.send(JSON.stringify({
+                type: 'log',
+                instance: name,
+                data: line,
+                timestamp: new Date().toISOString()
+              }));
+            }
+          } catch (err) {
+            // Socket might be closed
+          }
+        });
+
+        logProcess.stderr.on('data', (data) => {
+          try {
+            connection.socket.send(JSON.stringify({
+              type: 'error',
+              instance: name,
+              data: data.toString(),
+              timestamp: new Date().toISOString()
+            }));
+          } catch (err) {
+            // Socket might be closed
+          }
+        });
+
+        logProcess.on('close', (code) => {
+          connection.socket.send(JSON.stringify({
+            type: 'closed',
+            instance: name,
+            code,
+            timestamp: new Date().toISOString()
+          }));
+          activeStreams.delete(name);
+        });
+      }
+
+      connection.socket.on('close', () => {
+        fastify.log.info(`Log stream closed for: ${name}`);
+        if (activeStreams.has(name)) {
+          const stream = activeStreams.get(name);
+          stream.kill();
+          activeStreams.delete(name);
+        }
+      });
+
+      connection.socket.on('error', (err) => {
+        fastify.log.error(`WebSocket error for ${name}: ${err.message}`);
+      });
+    });
+  });
+
+  fastify.log.info('Log stream WebSocket registered');
+}