agent-window 1.2.0 → 1.2.3

package/src/api/routes/instances.js

@@ -24,6 +24,7 @@ import {
 } from '../../core/instance/pm2-bridge.js';
 import { readConfig, writeConfig } from '../../core/instance/config-reader.js';
 import { existsSync } from 'fs';
+import path from 'path';
 
 /**
  * Register instance routes
@@ -37,24 +38,8 @@ export async function registerInstanceRoutes(fastify) {
   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' }
-            }
-          }
-        }
-      }
+      tags: ['instances']
+      // Remove response schema to avoid field filtering
     }
   }, async (request, reply) => {
     try {
@@ -77,19 +62,8 @@ export async function registerInstanceRoutes(fastify) {
       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' }
-          }
-        }
       }
+      // Remove response schema to avoid field filtering
     }
   }, async (request, reply) => {
     try {
@@ -127,36 +101,84 @@ export async function registerInstanceRoutes(fastify) {
           projectPath: { type: 'string' },
           displayName: { type: 'string' },
           tags: { type: 'array', items: { type: 'string' } },
-          configPath: { type: 'string' }
+          configPath: { type: 'string' },
+          config: { type: 'object' },
+          createConfig: { type: 'boolean' }
         }
       }
     }
   }, async (request, reply) => {
     try {
-      const { name, projectPath, displayName, tags, configPath } = request.body;
+      const { name, projectPath, displayName, tags, configPath, config, createConfig } = request.body;
+
+      // If creating config file, ensure project path exists or create it
+      if (createConfig) {
+        const fs = await import('fs/promises');
+        const { existsSync } = await import('fs');
+
+        // Create project directory if it doesn't exist
+        if (!existsSync(projectPath)) {
+          try {
+            await fs.mkdir(projectPath, { recursive: true });
+          } catch (err) {
+            return reply.code(400).send({
+              error: 'Failed to create project directory',
+              message: err.message
+            });
+          }
+        }
 
-      // Validate project path exists
-      if (!existsSync(projectPath)) {
-        return reply.code(400).send({
-          error: 'Project path does not exist',
-          path: projectPath
+        // Write config file
+        const configFilePath = configPath || path.join(projectPath, 'config.json');
+        try {
+          await fs.writeFile(configFilePath, JSON.stringify(config, null, 2), 'utf-8');
+        } catch (err) {
+          return reply.code(400).send({
+            error: 'Failed to write config file',
+            message: err.message
+          });
+        }
+
+        // Use the created config path
+        const finalConfigPath = configFilePath;
+        const result = await addInstance(name, projectPath, {
+          displayName,
+          tags,
+          configPath: finalConfigPath
         });
-      }
 
-      const result = await addInstance(name, projectPath, {
-        displayName,
-        tags,
-        configPath
-      });
+        if (!result.success) {
+          return reply.code(400).send({
+            error: result.error,
+            validation: result.validation
+          });
+        }
 
-      if (!result.success) {
-        return reply.code(400).send({
-          error: result.error,
-          validation: result.validation
+        reply.code(201).send(result.instance);
+      } else {
+        // Validate project path exists for non-config creation
+        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
         });
-      }
 
-      reply.code(201).send(result.instance);
+        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',
@@ -438,5 +460,57 @@ export async function registerInstanceRoutes(fastify) {
     }
   });
 
+  /**
+   * GET /api/instances/tokens/claude
+   * Get Claude OAuth tokens from existing instances
+   */
+  fastify.get('/api/instances/tokens/claude', {
+    schema: {
+      description: 'Get Claude tokens from existing instances for reuse'
+    }
+  }, async (request, reply) => {
+    try {
+      const instances = await listInstances();
+      const tokens = [];
+
+      for (const instance of instances) {
+        try {
+          const result = await readConfig(instance.configPath);
+          if (!result.success) continue;
+
+          const config = JSON.parse(result.config);
+          if (config.CLAUDE_CODE_OAUTH_TOKEN) {
+            // Mask the token for security (show first 12 and last 4 characters)
+            const token = config.CLAUDE_CODE_OAUTH_TOKEN;
+            const masked = token.length > 16
+              ? `${token.substring(0, 12)}...${token.substring(token.length - 4)}`
+              : token;
+
+            tokens.push({
+              instanceName: instance.name,
+              displayName: instance.displayName || instance.name,
+              token: token, // Full token for reuse
+              maskedToken: masked, // Display version
+              instanceType: instance.instanceType
+            });
+          }
+        } catch (err) {
+          // Skip instances that can't be read
+          continue;
+        }
+      }
+
+      return {
+        success: true,
+        tokens
+      };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to get tokens',
+        message: error.message
+      });
+    }
+  });
+
   fastify.log.info('Instance routes registered');
 }

package/src/api/routes/operations.js

@@ -19,7 +19,7 @@ import { getInstance } from '../../core/instance/manager.js';
 
 // Get package root directory
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const PACKAGE_ROOT = path.join(__dirname, '..', '..', '..');
 
 /**
  * Register operation routes
@@ -183,5 +183,225 @@ export async function registerOperationRoutes(fastify) {
     }
   });
 
+  /**
+   * POST /api/validate-config
+   * Validate configuration before creating instance
+   */
+  fastify.post('/api/validate-config', {
+    schema: {
+      description: 'Validate instance configuration',
+      body: {
+        type: 'object',
+        required: ['config'],
+        properties: {
+          config: { type: 'object' },
+          projectPath: { type: 'string' }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { config, projectPath } = request.body;
+      const { existsSync } = await import('fs');
+      const { promisify } = await import('util');
+      const { exec } = await import('child_process');
+      const execAsync = promisify(exec);
+
+      const checks = [];
+      let allPassed = true;
+
+      // Check 1: Required fields
+      const requiredFields = ['BOT_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN', 'PROJECT_DIR', 'ALLOWED_CHANNELS'];
+      const missingFields = requiredFields.filter(field => !config[field]);
+
+      if (missingFields.length > 0) {
+        checks.push({
+          name: 'Required Fields',
+          status: 'failed',
+          message: `Missing fields: ${missingFields.join(', ')}`
+        });
+        allPassed = false;
+      } else {
+        checks.push({
+          name: 'Required Fields',
+          status: 'passed',
+          message: 'All required fields present'
+        });
+      }
+
+      // Check 2: Discord token format
+      if (config.BOT_TOKEN) {
+        if (config.BOT_TOKEN.startsWith('MT') || config.BOT_TOKEN.length >= 50) {
+          checks.push({
+            name: 'Discord Token Format',
+            status: 'passed',
+            message: 'Token format looks valid'
+          });
+        } else {
+          checks.push({
+            name: 'Discord Token Format',
+            status: 'warning',
+            message: 'Token format may be invalid (should start with MT and be long)'
+          });
+        }
+      }
+
+      // Check 3: Claude OAuth token format
+      if (config.CLAUDE_CODE_OAUTH_TOKEN) {
+        if (config.CLAUDE_CODE_OAUTH_TOKEN.startsWith('sk-ant-')) {
+          checks.push({
+            name: 'Claude OAuth Token Format',
+            status: 'passed',
+            message: 'Token format valid'
+          });
+        } else {
+          checks.push({
+            name: 'Claude OAuth Token Format',
+            status: 'failed',
+            message: 'Token must start with sk-ant-'
+          });
+          allPassed = false;
+        }
+      }
+
+      // Check 4: Project directory exists or can be created
+      if (config.PROJECT_DIR) {
+        if (existsSync(config.PROJECT_DIR)) {
+          checks.push({
+            name: 'Project Directory',
+            status: 'passed',
+            message: `Directory exists: ${config.PROJECT_DIR}`
+          });
+        } else if (projectPath) {
+          // Will be created
+          checks.push({
+            name: 'Project Directory',
+            status: 'warning',
+            message: `Will be created: ${config.PROJECT_DIR}`
+          });
+        } else {
+          checks.push({
+            name: 'Project Directory',
+            status: 'warning',
+            message: `Directory does not exist: ${config.PROJECT_DIR}`
+          });
+        }
+      }
+
+      // Check 5: Allowed channels format
+      if (config.ALLOWED_CHANNELS) {
+        const channels = config.ALLOWED_CHANNELS.split(',').map(c => c.trim()).filter(Boolean);
+        const validChannels = channels.every(c => /^\d+$/.test(c));
+
+        if (validChannels && channels.length > 0) {
+          checks.push({
+            name: 'Allowed Channels',
+            status: 'passed',
+            message: `${channels.length} channel(s) specified`
+          });
+        } else {
+          checks.push({
+            name: 'Allowed Channels',
+            status: 'warning',
+            message: 'Channel IDs should be numeric, comma-separated'
+          });
+        }
+      }
+
+      // Check 6: PM2 availability
+      try {
+        await execAsync('which pm2');
+        checks.push({
+          name: 'PM2 Installation',
+          status: 'passed',
+          message: 'PM2 is installed'
+        });
+      } catch {
+        checks.push({
+          name: 'PM2 Installation',
+          status: 'failed',
+          message: 'PM2 not found. Install: npm install -g pm2'
+        });
+        allPassed = false;
+      }
+
+      // Check 7: Docker availability AND functionality
+      try {
+        await execAsync('which docker');
+
+        // Actually test if Docker daemon is running
+        try {
+          const { stdout } = await execAsync('docker info');
+          checks.push({
+            name: 'Docker Installation',
+            status: 'passed',
+            message: 'Docker is installed and running'
+          });
+        } catch (dockerErr) {
+          checks.push({
+            name: 'Docker Installation',
+            status: 'warning',
+            message: 'Docker installed but daemon not running. Start Docker Desktop.'
+          });
+        }
+      } catch {
+        checks.push({
+          name: 'Docker Installation',
+          status: 'warning',
+          message: 'Docker not found (required for sandbox feature)'
+        });
+      }
+
+      // Check 8: Discord Token validation (basic format check)
+      if (config.BOT_TOKEN) {
+        // Discord tokens start with specific prefixes and are base64-like
+        const tokenValid = config.BOT_TOKEN.length >= 50 &&
+                           (config.BOT_TOKEN.startsWith('MT') ||
+                            config.BOT_TOKEN.includes('.') ||
+                            /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(config.BOT_TOKEN));
+
+        if (tokenValid) {
+          checks.push({
+            name: 'Discord Token Validation',
+            status: 'passed',
+            message: 'Token format appears valid'
+          });
+        } else {
+          checks.push({
+            name: 'Discord Token Validation',
+            status: 'warning',
+            message: 'Token format may be invalid (should be 50+ chars with dots)'
+          });
+        }
+      }
+
+      // Check 9: AgentWindow bot.js exists
+      if (existsSync(path.join(PACKAGE_ROOT, 'src', 'bot.js'))) {
+        checks.push({
+          name: 'AgentWindow Installation',
+          status: 'passed',
+          message: 'AgentWindow bot.js found'
+        });
+      } else {
+        checks.push({
+          name: 'AgentWindow Installation',
+          status: 'failed',
+          message: `AgentWindow bot.js not found at ${path.join(PACKAGE_ROOT, 'src', 'bot.js')}`
+        });
+        allPassed = false;
+      }
+
+      return {
+        success: allPassed,
+        checks
+      };
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Validation failed',
+        message: error.message
+      });
+    }
+  });
+
   fastify.log.info('Operation routes registered');
 }