agent-window 1.3.8 → 1.4.0

package/hooks/settings.json

@@ -11,5 +11,72 @@
         ]
       }
     ]
+  },
+  "permissions": {
+    "allow": [
+      "WebSearch",
+      "Bash(npm install)",
+      "Bash(pm2 list:*)",
+      "Bash(pm2 start:*)",
+      "Bash(pm2 logs:*)",
+      "WebFetch(domain:github.com)",
+      "Bash(docker stop:*)",
+      "Bash(docker rm:*)",
+      "Bash(pm2 restart:*)",
+      "Bash(docker exec:*)",
+      "Bash(docker logs:*)",
+      "Bash(pm2 flush:*)",
+      "Bash(chmod:*)",
+      "Bash(node bin/cli.js:*)",
+      "Bash(node /Users/cyrus/Documents/project/discord-cli-bot/bin/cli.js:*)",
+      "Bash(pm2 stop:*)",
+      "Bash(pm2 delete:*)",
+      "Bash(git checkout:*)",
+      "Skill(bmad:bmm:workflows:quick-spec)",
+      "Skill(bmad:bmb:workflows:module)",
+      "Skill(bmad:bmb:workflows:quick-dev)",
+      "Bash(git rev-parse:*)",
+      "Bash(node --check:*)",
+      "Bash(npm init -y)",
+      "Bash(node:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(python3:*)",
+      "WebFetch(domain:www.vibesparking.com)",
+      "WebFetch(domain:docs.z.ai)",
+      "Bash(claude mcp search:*)",
+      "Bash(npm search:*)",
+      "Bash(npm view:*)",
+      "WebFetch(domain:docs.bigmodel.cn)",
+      "mcp__web-search-prime__webSearchPrime",
+      "mcp__web-reader__webReader",
+      "Bash(docker stats:*)",
+      "Bash(git stash:*)",
+      "Bash(git -C /Users/cyrus/Documents/project/corp-office/finance-department log:*)",
+      "Bash(git -C /Users/cyrus/Documents/project/corp-office/finance-department status)",
+      "Bash(lsof:*)",
+      "Bash(pwdx:*)",
+      "Bash(docker:*)",
+      "Bash(kill:*)",
+      "Bash(pkill:*)",
+      "Bash(env:*)",
+      "Bash(compgen:*)",
+      "Bash(claude:*)",
+      "Bash(for:*)",
+      "Bash(do echo:*)",
+      "Bash(done:*)",
+      "mcp__zai-mcp-server__analyze_image",
+      "mcp__zread__search_doc",
+      "mcp__zread__get_repo_structure",
+      "mcp__zread__read_file",
+      "mcp__zai-mcp-server__extract_text_from_screenshot",
+      "mcp__zai-mcp-server__ui_to_artifact",
+      "mcp__zai-mcp-server__understand_technical_diagram",
+      "mcp__zai-mcp-server__diagnose_error_screenshot",
+      "mcp__zai-mcp-server__analyze_data_visualization",
+      "mcp__zai-mcp-server__analyze_video",
+      "Skill(bmad:core:workflows:party-mode)",
+      "Skill(bmad:core:agents:bmad-master)"
+    ]
   }
 }

package/install-bmad-automated.exp

@@ -0,0 +1,91 @@
+#!/usr/bin/expect -f
+
+# BMAD Framework Automated Installation Script
+# This script automates the BMAD framework installation
+
+set timeout 120
+
+# Check if expect is installed
+if {catch {exec expect <<  EOC
+    package require Expect
+    EOC
+}} {
+    puts "Error: expect is not installed"
+    puts "Install with: brew install expect"
+    exit 1
+}
+
+puts "\n🔧 BMAD Framework Automated Installer"
+puts "==================================\n"
+
+# Change to project directory
+cd /Users/cyrus/Documents/project/agent-window-main
+
+puts "📍 Current directory: [exec pwd]"
+puts "🚀 Starting: npx observer-ggboy-bmad-method install\n"
+
+# Spawn the installer
+spawn npx observer-gyboy-bmad-method install
+
+# Wait for installer to load
+expect {
+    -timeout 30
+    "Installation directory:"
+}
+
+puts "\n✓ Installer loaded"
+puts "\n⚠️  IMPORTANT: Please make selections manually:"
+puts "   1. Use ↑↓ arrows to navigate"
+puts "   2. Press SPACE to select/deselect modules"
+puts "   3. SKIP 'agent-window' module (your project)"
+puts "   4. Install official BMAD modules:"
+puts "      - bmad-builder"
+puts "      - bmad-creative-intelligence-suite"
+puts "      - bmad-game-dev-studio"
+puts "   5. Press ENTER to start installation"
+puts "\n📝 Press ENTER when ready to see selections...\n"
+
+# Wait for user to press Enter
+expect {
+    "\n"
+    puts "\n✓ Ready. Proceeding with installation..."
+    exp_continue
+}
+
+# Wait for installation to complete
+expect {
+    timeout 300
+    eof
+}
+
+puts "\n✅ Installation completed!"
+puts "\n🔍 Verifying installation..."
+
+# Check if BMAD files were installed
+after 3 {
+    if {[file exists "_bmad/core/agents"]} {
+        puts "✓ BMAD core files installed"
+    } else {
+        puts "⚠️  BMAD core files not found"
+    }
+
+    if {[file exists "_bmad/bmm/agents"]} {
+        puts "✓ BMM module installed"
+    } else {
+        puts "⚠️  BMM module not found"
+    }
+
+    if {[file exists "_bmad/bmb/agents"]} {
+        puts "✓ BMB module installed"
+    } else {
+        puts "⚠️  BMB module not found"
+    }
+}
+
+puts "\n📚 Next steps:"
+puts "1. Check _bmad/ directory structure"
+puts "2. Test BMAD commands in Claude Code by typing /"
+puts "3. Read BMAD-INSTALL-GUIDE.md for detailed information\n"
+
+puts "Press ENTER to exit..."
+expect user "\n"

package/install-bmad-interactive.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# BMAD Framework Installation Script
+# Interactive installation that preserves existing files
+
+echo "🔧 BMAD Framework Installer"
+echo ""
+echo "Starting: npx observer-ggboy-bmad-method install"
+echo ""
+
+# Run installer in background with input stream
+{
+  # Wait a bit for installer to start
+  sleep 3
+
+  # Check if it's asking about modules
+  echo "Skipping AgentWindow module installation..."
+
+} | npx observer-ggboy-bmad-method install
+
+echo ""
+echo "✅ Installation complete!"

package/install-bmad.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * BMAD Framework Installation Script
+ * Interactive installer that preserves existing files
+ */
+
+const { spawn } = require('child_process');
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+
+class BMADInstaller {
+  constructor() {
+    this.bmadDir = path.join(process.cwd(), '_bmad');
+    this.installer = null;
+  }
+
+  log(message) {
+    console.log(`[BMAD Installer] ${message}`);
+  }
+
+  async checkExistingFiles() {
+    this.log('Checking existing BMAD files...');
+
+    const existing = [];
+
+    // Check core directories
+    const coreDirs = ['agents', 'tasks', 'workflows', 'resources'];
+    const corePath = path.join(this.bmadDir, 'core');
+
+    if (fs.existsSync(corePath)) {
+      for (const dir of coreDirs) {
+        const dirPath = path.join(corePath, dir);
+        if (fs.existsSync(dirPath)) {
+          const files = fs.readdirSync(dirPath);
+          if (files.length > 0) {
+            existing.push(`core/${dir}/ (${files.length} files)`);
+          }
+        }
+      }
+    }
+
+    // Check modules
+    const modules = ['bmm', 'bmb'];
+    for (const mod of modules) {
+      const modPath = path.join(this.bmadDir, mod);
+      if (fs.existsSync(modPath)) {
+        const files = fs.readdirSync(modPath, { recursive: true });
+        existing.push(`${mod}/ (${files.length} files)`);
+      }
+    }
+
+    if (existing.length > 0) {
+      this.log(`Found existing files:\n  - ${existing.join('\n  - ')}`);
+    } else {
+      this.log('No existing BMAD framework files found');
+    }
+
+    return existing;
+  }
+
+  async runInteractive(input) {
+    return new Promise((resolve, reject) => {
+      this.log('Starting BMAD framework installer...');
+      this.log('Command: npx observer-ggboy-bmad-method install');
+
+      this.installer = spawn('npm', ['exec', 'observer-ggboy-bmad-method', 'install'], {
+        cwd: process.cwd(),
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let output = '';
+      let prompt = '';
+
+      this.installer.stdout.on('data', (data) => {
+        const text = data.toString();
+        output += text;
+        process.stdout.write(text);
+
+        // Check if installer is waiting for input
+        if (text.includes('?') || text.includes('Select')) {
+          prompt = text;
+        }
+      });
+
+      this.installer.stderr.on('data', (data) => {
+        process.stderr.write(data);
+      });
+
+      this.installer.on('close', (code) => {
+        if (code === 0) {
+          this.log('✅ Installation completed');
+          resolve(output);
+        } else {
+          this.log(`Installer exited with code ${code}`);
+          resolve(output);
+        }
+      });
+
+      // Send input if provided
+      if (input) {
+        setTimeout(() => {
+          this.installer.stdin.write(input + '\n');
+        }, 1000);
+      }
+    });
+  }
+
+  async installWithDefaults() {
+    this.log('Installing with default options (skip AgentWindow module)...');
+
+    // The installer will ask which modules to install
+    // We'll provide default answers
+    const responses = [
+      // Skip AgentWindow module (we want official modules only)
+      '\n', // Press Enter to skip AgentWindow
+    ];
+
+    for (const response of responses) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      this.installer.stdin.write(response);
+    }
+  }
+}
+
+// Main installation
+async function main() {
+  const installer = new BMADInstaller();
+
+  console.log('\n🔧 BMAD Framework Interactive Installer\n');
+  console.log('This will install the BMAD framework without overwriting existing files.\n');
+
+  await installer.checkExistingFiles();
+
+  console.log('\nStarting interactive installer...');
+  console.log('Note: When prompted, SKIP the AgentWindow module installation.');
+  console.log('Only install official BMAD modules (core, bmm, bmb).\n');
+
+  await installer.runInteractive();
+
+  console.log('\n✅ Installation complete!\n');
+}
+
+main().catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "agent-window",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "description": "A window to interact with AI agents through chat interfaces. Simplified interaction, powerful backend capabilities.",
   "type": "module",
   "main": "src/bot.js",
-  "bin": {
-    "agent-window": "./bin/cli.js"
-  },
   "scripts": {
     "start": "node src/bot.js",
     "dev": "node --watch src/bot.js",
@@ -15,23 +12,16 @@
     "ui:dev": "cd web && npm run dev",
     "ui:build": "cd web && npm run build",
     "pm2:start": "pm2 start ecosystem.config.cjs",
-    "pm2:stop": "pm2 stop agent-window",
-    "pm2:restart": "pm2 restart agent-window",
-    "pm2:logs": "pm2 logs agent-window"
+    "pm2:stop": "pm2 stop bot-corp",
+    "pm2:restart": "pm2 restart bot-corp",
+    "pm2:logs": "pm2 logs bot-corp"
   },
   "keywords": [
-    "agent",
-    "window",
     "discord",
-    "slack",
     "bot",
+    "bmad",
     "claude",
-    "ai",
-    "cli",
-    "docker",
-    "sandbox",
-    "chat",
-    "interface"
+    "ai"
   ],
   "author": "",
   "license": "MIT",
@@ -49,9 +39,5 @@
   },
   "overrides": {
     "undici": "^7.19.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Observer-GGboy/AgentWindow"
   }
 }

package/src/api/routes/instances.js

@@ -24,7 +24,9 @@ import {
   getLogs
 } from '../../core/instance/pm2-bridge.js';
 import { readConfig, writeConfig } from '../../core/instance/config-reader.js';
+import { paths } from '../../core/platform/index.js';
 import { existsSync } from 'fs';
+import { promises as fs } from 'fs';
 import path from 'path';
 
 /**
@@ -113,27 +115,68 @@ export async function registerInstanceRoutes(fastify) {
     try {
       const { name, projectPath, displayName, tags, configPath, config, createConfig, instanceType } = request.body;
 
-      // If creating config file, ensure project path exists or create it
+      // If creating config file, ensure directories exist
       if (createConfig) {
-        const fs = await import('fs/promises');
-        const { existsSync } = await import('fs');
+        // For simple-config instances, config goes in botsDir/{name}/config.json
+        // For bmad-plugin instances, config goes in project directory
+        let configFilePath;
+        const effectiveInstanceType = instanceType || 'simple-config';
+
+        if (effectiveInstanceType === 'simple-config') {
+          // Simple-config: use botsDir/{name}/config.json
+          const botsDir = paths.getBotsDir();
+          configFilePath = configPath || path.join(botsDir, name, 'config.json');
+
+          // Ensure bots directory exists
+          if (!existsSync(botsDir)) {
+            try {
+              await fs.mkdir(botsDir, { recursive: true });
+            } catch (err) {
+              return reply.code(400).send({
+                error: 'Failed to create bots directory',
+                message: err.message
+              });
+            }
+          }
 
-        // 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
-            });
+          // Create instance directory (botsDir/{name})
+          const instanceDir = path.dirname(configFilePath);
+          if (!existsSync(instanceDir)) {
+            try {
+              await fs.mkdir(instanceDir, { recursive: true });
+            } catch (err) {
+              return reply.code(400).send({
+                error: 'Failed to create instance directory',
+                message: err.message
+              });
+            }
+          }
+        } else {
+          // BMAD plugin: use projectPath/config.json
+          configFilePath = configPath || path.join(projectPath, 'config.json');
+
+          // 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
+              });
+            }
           }
         }
 
         // Write config file
-        const configFilePath = configPath || path.join(projectPath, 'config.json');
         try {
-          await fs.writeFile(configFilePath, JSON.stringify(config, null, 2), 'utf-8');
+          // Ensure dockerImage uses local claude-sandbox if workspace specified but no dockerImage
+          const finalConfig = { ...config };
+          if (finalConfig.workspace && finalConfig.workspace.containerName && !finalConfig.workspace.dockerImage) {
+            finalConfig.workspace.dockerImage = 'claude-sandbox';
+          }
+
+          await fs.writeFile(configFilePath, JSON.stringify(finalConfig, null, 2), 'utf-8');
         } catch (err) {
           return reply.code(400).send({
             error: 'Failed to write config file',
@@ -148,7 +191,7 @@ export async function registerInstanceRoutes(fastify) {
           tags,
           configPath: finalConfigPath,
           createConfig: true,
-          instanceType: instanceType || 'simple-config'
+          instanceType: effectiveInstanceType
         });
 
         if (!result.success) {

package/src/api/routes/operations.js

@@ -108,19 +108,20 @@ export async function registerOperationRoutes(fastify) {
       };
 
       // Check if process already exists in PM2
-      const { getProcess } = await import('../../core/instance/pm2-bridge.js');
+      const { getProcess, deleteProcess } = await import('../../core/instance/pm2-bridge.js');
       const existingProc = await getProcess(botName);
 
-      let result;
-      if (existingProc && existingProc.status !== 'stopped') {
-        // Process is already running or in errored state - restart it
-        const { restartProcess } = await import('../../core/instance/pm2-bridge.js');
-        result = await restartProcess(botName);
-      } else {
-        // Process doesn't exist or is stopped - start it
-        result = await startProcess(scriptPath, botName, options);
+      // Always delete existing process before starting to ensure:
+      // 1. Fresh configuration (environment variables)
+      // 2. No duplicate instances
+      // 3. Clean state (no stale resurrected processes)
+      if (existingProc) {
+        await deleteProcess(botName);
       }
 
+      // Start with fresh configuration
+      const result = await startProcess(scriptPath, botName, options);
+
       if (!result.success) {
         return reply.code(400).send({
           error: result.error,
@@ -202,8 +203,37 @@ export async function registerOperationRoutes(fastify) {
         });
       }
 
+      // Normalize instance type
+      const normalizedType = normalizeInstanceType(instance.instanceType);
+
+      // Determine script path
+      let scriptPath;
+      const cwd = instance.projectPath;
+
+      switch (normalizedType) {
+        case 'bmad-plugin':
+          scriptPath = path.join(instance.projectPath, '_agent-bridge', 'src', 'bot.js');
+          break;
+        case 'simple-config':
+        default:
+          scriptPath = path.join(PACKAGE_ROOT, 'src', 'bot.js');
+          break;
+      }
+
       const botName = instance.botName || `bot-${name}`;
-      const result = await restartProcess(botName);
+
+      // For restart, delete and start fresh to update env vars
+      const { deleteProcess, startProcess } = await import('../../core/instance/pm2-bridge.js');
+      await deleteProcess(botName);
+
+      const options = {
+        cwd,
+        env: {
+          CONFIG_PATH: instance.configPath
+        }
+      };
+
+      const result = await startProcess(scriptPath, botName, options);
 
       if (!result.success) {
         return reply.code(400).send({