ai-extension-preview 0.1.14 → 0.1.16

package/dist/index.js

@@ -3,18 +3,9 @@ import 'dotenv/config'; // Load .env
 import { Command } from 'commander';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import fs from 'fs-extra';
 import os from 'os';
 import { Runtime } from 'skeleton-crew-runtime';
-import { CorePlugin } from './plugins/CorePlugin.js';
-import { DownloaderPlugin } from './plugins/DownloaderPlugin.js';
-import { BrowserManagerPlugin } from './plugins/browser/BrowserManagerPlugin.js';
-import { WSLLauncherPlugin } from './plugins/browser/WSLLauncherPlugin.js';
-import { NativeLauncherPlugin } from './plugins/browser/NativeLauncherPlugin.js';
-import { ServerPlugin } from './plugins/ServerPlugin.js';
-import axios from 'axios';
 import chalk from 'chalk';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const DEFAULT_HOST = process.env.API_HOST || 'https://ai-extension-builder.01kb6018z1t9tpaza4y5f1c56w.lmapp.run/api';
 const program = new Command();
 program
@@ -26,138 +17,47 @@ program
     .option('--user <user>', 'User ID (if required)')
     .parse(process.argv);
 const options = program.opts();
-async function authenticate(host, port) {
-    try {
-        // 1. Init Session with port
-        console.log('[DEBUG] Sending port to backend:', port);
-        const initRes = await axios({
-            method: 'post',
-            url: `${host}/preview/init`,
-            data: { port },
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
-        console.log('[DEBUG] Init response:', initRes.data);
-        const { code, sessionId } = initRes.data;
-        console.log('\n' + chalk.bgBlue.bold(' DETACHED PREVIEW MODE ') + '\n');
-        console.log('To connect, please go to your Extension Dashboard and click "Connect Preview".');
-        console.log('Enter the following code:');
-        console.log('\n' + chalk.green.bold(`  ${code}  `) + '\n');
-        console.log('Waiting for connection...');
-        // 2. Poll for Status
-        while (true) {
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            try {
-                const statusRes = await axios.get(`${host}/preview/status/${sessionId}`);
-                const data = statusRes.data;
-                if (data.status === 'linked') {
-                    console.log(chalk.green('✔ Connected!'));
-                    if (!data.jobId) {
-                        console.error('Error: No Job ID associated with this connection.');
-                        process.exit(1);
-                    }
-                    console.log('[DEBUG] Received userId:', data.userId);
-                    console.log('[DEBUG] Received jobId:', data.jobId);
-                    return {
-                        jobId: data.jobId,
-                        userId: data.userId,
-                        token: data.token || ''
-                    };
-                }
-                if (data.status === 'expired') {
-                    console.error(chalk.red('Code expired. Please restart.'));
-                    process.exit(1);
-                }
-            }
-            catch (err) {
-                // Ignore poll errors, keep trying
-            }
-        }
-    }
-    catch (error) {
-        console.error('Authentication failed:', error);
-        throw error;
-    }
-}
+// Define __dirname for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 // Use os.homedir() to ensure we have write permissions
-// Git Bash sometimes defaults cwd to C:\Program Files\Git which causes EPERM
 const HOME_DIR = os.homedir();
-const WORK_DIR = path.join(HOME_DIR, '.ai-extension-preview', options.job || 'default'); // Use default if job not provided yet
+// Initial workdir based on options, or specific 'default' if not yet known.
+// AuthPlugin will update this if job changes.
+const WORK_DIR = path.join(HOME_DIR, '.ai-extension-preview', options.job || 'default');
 (async () => {
-    const { job: jobId, host, token, user: userId } = options;
-    // 1. Initialize Runtime first to allocate port
+    const { job: initialJobId, host, token, user: userId } = options;
+    // 1. Initialize Runtime with Config
     const runtime = new Runtime({
-        hostContext: {
-            config: {
-                host,
-                token: token || '',
-                user: userId || '',
-                jobId: jobId || '',
-                workDir: WORK_DIR
-            }
-        }
+        config: {
+            host,
+            token: token || '',
+            user: userId || '',
+            jobId: initialJobId || '',
+            workDir: WORK_DIR
+        },
+        hostContext: {}, // Clear hostContext config wrapping
+        pluginPaths: [path.join(__dirname, 'plugins')] // [NEW] Auto-discovery
     });
-    runtime.logger.info('Registering plugins...');
-    runtime.registerPlugin(CorePlugin);
-    runtime.registerPlugin(DownloaderPlugin);
-    runtime.registerPlugin(BrowserManagerPlugin);
-    runtime.registerPlugin(WSLLauncherPlugin);
-    runtime.registerPlugin(NativeLauncherPlugin);
-    runtime.registerPlugin(ServerPlugin);
+    // Register Plugins
     runtime.logger.info('Initializing runtime...');
     await runtime.initialize();
     const ctx = runtime.getContext();
-    // Get allocated port from ServerPlugin
-    const allocatedPort = ctx.hotReloadPort;
-    if (!allocatedPort) {
-        console.error('Failed to allocate server port');
-        process.exit(1);
-    }
-    // 2. Now authenticate with the allocated port
-    let finalJobId = jobId;
-    let finalUserId = userId;
-    let finalToken = token;
-    if (!jobId || !userId) {
-        const authData = await authenticate(host, allocatedPort);
-        finalJobId = authData.jobId;
-        finalUserId = authData.userId;
-        finalToken = authData.token;
-        // Update runtime config with auth data
-        ctx.host.config.jobId = finalJobId;
-        ctx.host.config.user = finalUserId;
-        ctx.host.config.token = finalToken;
-    }
-    // 3. Start LifeCycle
-    await ctx.actions.runAction('core:log', { level: 'info', message: 'Initializing Local Satellite...' });
-    // Ensure work dir exists
-    await fs.ensureDir(WORK_DIR);
-    // Initial Check - Must succeed to continue
-    const success = await ctx.actions.runAction('downloader:check', null);
-    if (!success) {
-        await ctx.actions.runAction('core:log', { level: 'error', message: 'Initial check failed. Could not verify job or download extension.' });
-        process.exit(1);
-    }
-    // Wait for Extension files (Manifest)
-    const manifestPath = path.join(WORK_DIR, 'dist', 'manifest.json');
-    let attempts = 0;
-    const maxAttempts = 60; // 2 minutes
-    console.log('[DEBUG] Waiting for extension files...');
-    while (!fs.existsSync(manifestPath) && attempts < maxAttempts) {
-        await new Promise(r => setTimeout(r, 2000));
-        attempts++;
-        if (attempts % 5 === 0)
-            console.log(`Waiting for extension generation... (${attempts * 2}s)`);
+    // 2. Start App Flow
+    try {
+        await ctx.actions.runAction('app:start', null);
     }
-    if (!fs.existsSync(manifestPath)) {
-        await ctx.actions.runAction('core:log', { level: 'error', message: 'Timed out waiting for extension files. Status check succeeded but files are missing.' });
+    catch (error) {
+        console.error(chalk.red('App Error:'), error.message);
+        await runtime.shutdown();
         process.exit(1);
     }
-    // Launch Browser
-    await ctx.actions.runAction('browser:start', {});
-    // Keep process alive
+    // Keep process alive handled by Node event loop because ServerPlugin has an open server
+    // and Browser processes might be attached. 
+    // Graceful Shutdown
     process.on('SIGINT', async () => {
         await ctx.actions.runAction('core:log', { level: 'info', message: 'Shutting down...' });
+        await runtime.shutdown();
         process.exit(0);
     });
     runtime.logger.info('Press Ctrl+C to exit.');
@@ -168,7 +68,6 @@ const WORK_DIR = path.join(HOME_DIR, '.ai-extension-preview', options.job || 'de
 // Handle global errors
 process.on('uncaughtException', (err) => {
     if (err.code === 'ECONNRESET' || err.message?.includes('ECONNRESET')) {
-        // Ignore pipe errors frequently caused by web-ext/chrome teardown
         return;
     }
     console.error('Uncaught Exception:', err);

package/dist/plugins/AppPlugin.js

@@ -0,0 +1,59 @@
+import fs from 'fs-extra';
+import path from 'path';
+export const AppPlugin = {
+    name: 'app',
+    version: '1.0.0',
+    dependencies: ['auth', 'config', 'downloader', 'browser-manager', 'server'],
+    setup(ctx) {
+        ctx.actions.registerAction({
+            id: 'app:start',
+            handler: async () => {
+                await ctx.logger.info('Initializing Local Satellite...');
+                // 1. Authenticate (if needed)
+                // AuthPlugin will automatically skip if already config'd, or prompt if needed
+                // It will also update config via config:set
+                await ctx.actions.runAction('auth:login');
+                // 2. Validate Configuration (Now that we have potential Auth data)
+                try {
+                    await ctx.actions.runAction('config:validate', null);
+                }
+                catch (e) {
+                    throw new Error(`Configuration Invalid: ${e.message}`);
+                }
+                // 3. Get Updated Config
+                const workDir = ctx.config.workDir;
+                // 3. Ensure Work Directory
+                await fs.ensureDir(workDir);
+                // 4. Initial Download/Check
+                const success = await ctx.actions.runAction('downloader:check', null);
+                if (!success) {
+                    await ctx.logger.error('Initial check failed. Could not verify job or download extension.');
+                    // We don't exit process here, but we might throw to stop flow
+                    throw new Error('Initial check failed');
+                }
+                // 5. Wait for Extension Manifest
+                const manifestPath = path.join(workDir, 'dist', 'manifest.json');
+                let attempts = 0;
+                const maxAttempts = 60; // 2 minutes
+                // This logic could be in a 'watcher' plugin but fits here for now as part of "Startup Sequence"
+                if (!fs.existsSync(manifestPath)) {
+                    await ctx.logger.info('[DEBUG] Waiting for extension files...');
+                    while (!fs.existsSync(manifestPath) && attempts < maxAttempts) {
+                        await new Promise(r => setTimeout(r, 2000));
+                        attempts++;
+                        if (attempts % 5 === 0) {
+                            await ctx.logger.info(`Waiting for extension generation... (${attempts * 2}s)`);
+                        }
+                    }
+                }
+                if (!fs.existsSync(manifestPath)) {
+                    await ctx.logger.error('Timed out waiting for extension files. Status check succeeded but files are missing.');
+                    throw new Error('Timeout waiting for files');
+                }
+                // 6. Launch Browser
+                await ctx.actions.runAction('browser:start', {});
+            }
+        });
+    }
+};
+export default AppPlugin;

package/dist/plugins/AuthPlugin.js

@@ -0,0 +1,89 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+const AuthPlugin = {
+    name: 'auth',
+    version: '1.0.0',
+    dependencies: ['config', 'server'],
+    setup(ctx) {
+        ctx.actions.registerAction({
+            id: 'auth:login',
+            handler: async () => {
+                const hostContext = ctx.config;
+                // If we already have JobID and UserID, we might skip, but let's assume we need to verify or start fresh if missing
+                if (hostContext.jobId && hostContext.user) {
+                    await ctx.logger.info('Auth: Job ID and User ID present. Skipping login.');
+                    return { jobId: hostContext.jobId, user: hostContext.user, token: hostContext.token };
+                }
+                // We need the port from ServerPlugin
+                // We need the port from ServerPlugin
+                const allocatedPort = ctx.config.hotReloadPort;
+                if (!allocatedPort) {
+                    throw new Error('Server port not found. Ensure ServerPlugin is loaded before AuthPlugin logic runs.');
+                }
+                const host = hostContext.host;
+                await ctx.logger.info(`Auth: Initiating login flow on ${host} with port ${allocatedPort}`);
+                try {
+                    // 1. Init Session with port
+                    const initRes = await axios({
+                        method: 'post',
+                        url: `${host}/preview/init`,
+                        data: { port: allocatedPort },
+                        headers: { 'Content-Type': 'application/json' }
+                    });
+                    const { code, sessionId } = initRes.data;
+                    console.log('\n' + chalk.bgBlue.bold(' DETACHED PREVIEW MODE ') + '\n');
+                    console.log('To connect, please go to your Extension Dashboard and click "Connect Preview".');
+                    console.log('Enter the following code:');
+                    console.log('\n' + chalk.green.bold(`  ${code}  `) + '\n');
+                    console.log('Waiting for connection...');
+                    // 2. Poll for Status
+                    let attempts = 0;
+                    while (true) {
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                        attempts++;
+                        // Check if we should abort (e.g. from a cancel signal? unimplemented for now)
+                        try {
+                            const statusRes = await axios.get(`${host}/preview/status/${sessionId}`);
+                            const data = statusRes.data;
+                            if (data.status === 'linked') {
+                                console.log(chalk.green('✔ Connected!'));
+                                if (!data.jobId) {
+                                    throw new Error('No Job ID associated with this connection.');
+                                }
+                                const authData = {
+                                    jobId: data.jobId,
+                                    user: data.userId,
+                                    token: data.token || ''
+                                };
+                                // UPGRADE CONFIG
+                                await ctx.actions.runAction('config:set', {
+                                    jobId: authData.jobId,
+                                    user: authData.user,
+                                    token: authData.token,
+                                    workDir: path.join(os.homedir(), '.ai-extension-preview', authData.jobId)
+                                });
+                                return authData;
+                            }
+                            if (data.status === 'expired') {
+                                throw new Error('Code expired. Please restart.');
+                            }
+                        }
+                        catch (err) {
+                            if (err.message && (err.message.includes('expired') || err.message.includes('No Job ID'))) {
+                                throw err;
+                            }
+                            // Ignore poll errors
+                        }
+                    }
+                }
+                catch (error) {
+                    await ctx.logger.error(`Authentication failed: ${error.message}`);
+                    throw error;
+                }
+            }
+        });
+    }
+};
+export default AuthPlugin;

package/dist/plugins/ConfigPlugin.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+const ConfigPlugin = {
+    name: 'config',
+    version: '1.0.0',
+    dependencies: [],
+    async setup(ctx) {
+        // 1. Define Schema
+        const configSchema = z.object({
+            host: z.string().url(),
+            jobId: z.string().min(1, "Job ID is required"),
+            token: z.string().optional(),
+            user: z.string().optional(),
+            workDir: z.string()
+        });
+        ctx.actions.registerAction({
+            id: 'config:validate',
+            handler: async () => {
+                const config = ctx.config;
+                try {
+                    configSchema.parse(config);
+                    return true;
+                }
+                catch (error) {
+                    if (error instanceof z.ZodError) {
+                        const issues = error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join(', ');
+                        await ctx.actions.runAction('core:log', { level: 'error', message: `Config Validation Failed: ${issues}` });
+                    }
+                    throw error;
+                }
+            }
+        });
+        // [NEW] Allow runtime config updates
+        ctx.actions.registerAction({
+            id: 'config:set',
+            handler: async (payload) => {
+                ctx.getRuntime().updateConfig(payload);
+                const config = ctx.config;
+                // Validate after set? Optional, but good practice.
+                try {
+                    configSchema.parse(config);
+                }
+                catch (e) {
+                    // Log but don't revert for now, trust the caller or add rollback logic if needed.
+                    // Just warn for now
+                    await ctx.actions.runAction('core:log', { level: 'warn', message: 'Config updated but validation failed. Some features may not work.' });
+                }
+                return config;
+            }
+        });
+    }
+};
+export default ConfigPlugin;

package/dist/plugins/CorePlugin.js

@@ -1,11 +1,10 @@
 import chalk from 'chalk';
-export const CorePlugin = {
+const CorePlugin = {
     name: 'core',
     version: '1.0.0',
     setup(ctx) {
         console.log('CorePlugin: setup called');
-        // We assume config is passed in hostContext
-        const config = ctx.host.config;
+        const config = ctx.config;
         ctx.actions.registerAction({
             id: 'core:config',
             handler: async () => config
@@ -15,9 +14,7 @@ export const CorePlugin = {
             id: 'core:log',
             handler: async (payload) => {
                 // Access default logger from Runtime
-                const rt = typeof ctx.getRuntime === 'function' ? ctx.getRuntime() : ctx.runtime;
-                // Logger is now public
-                const logger = rt.logger || console;
+                const logger = ctx.logger;
                 const { level, message } = payload;
                 switch (level) {
                     case 'error':
@@ -41,3 +38,4 @@ export const CorePlugin = {
         });
     }
 };
+export default CorePlugin;

package/dist/plugins/DownloaderPlugin.js

@@ -5,15 +5,23 @@ import AdmZip from 'adm-zip';
 import ora from 'ora';
 import https from 'https';
 let checkInterval;
-export const DownloaderPlugin = {
+const DownloaderPlugin = {
     name: 'downloader',
     version: '1.0.0',
+    dependencies: ['config'],
     setup(ctx) {
-        const config = ctx.host.config;
-        const DIST_DIR = path.join(config.workDir, 'dist');
-        const DOWNLOAD_PATH = path.join(config.workDir, 'extension.zip');
+        // Helper to get paths dynamically
+        const getPaths = () => {
+            const workDir = ctx.config.workDir;
+            return {
+                DIST_DIR: path.join(workDir, 'dist'),
+                DOWNLOAD_PATH: path.join(workDir, 'extension.zip'),
+                VERSION_FILE: path.join(workDir, 'version')
+            };
+        };
         // Helper function to create axios client with current config
         const createClient = () => {
+            const config = ctx.config;
             const rawToken = config.token ? String(config.token) : '';
             const token = rawToken.replace(/^Bearer\s+/i, '').trim();
             // Auto-extract user ID from token if not provided
@@ -30,7 +38,7 @@ export const DownloaderPlugin = {
                     // Ignore parse errors
                 }
             }
-            ctx.actions.runAction('core:log', { level: 'info', message: `[DEBUG] DownloaderPlugin creating client with userId: ${userId}` });
+            ctx.logger.info(`[DEBUG] DownloaderPlugin creating client with userId: ${userId}`);
             return axios.create({
                 baseURL: config.host,
                 headers: {
@@ -42,11 +50,16 @@ export const DownloaderPlugin = {
                 })
             });
         };
-        const VERSION_FILE = path.join(config.workDir, 'version');
         let lastModified = '';
-        if (fs.existsSync(VERSION_FILE)) {
-            lastModified = fs.readFileSync(VERSION_FILE, 'utf-8').trim();
+        let currentWorkDir = '';
+        // Check initial state if workDir exists
+        try {
+            const { VERSION_FILE } = getPaths();
+            if (fs.existsSync(VERSION_FILE)) {
+                lastModified = fs.readFileSync(VERSION_FILE, 'utf-8').trim();
+            }
         }
+        catch (e) { }
         let isChecking = false;
         // Action: Check Status
         ctx.actions.registerAction({
@@ -55,12 +68,23 @@ export const DownloaderPlugin = {
                 if (isChecking)
                     return true; // Skip if busy
                 isChecking = true;
+                const { jobId, workDir } = ctx.config;
+                const { DIST_DIR, VERSION_FILE } = getPaths();
+                // Reset lastModified if workDir changed
+                if (workDir !== currentWorkDir) {
+                    currentWorkDir = workDir;
+                    lastModified = '';
+                    if (fs.existsSync(VERSION_FILE)) {
+                        lastModified = fs.readFileSync(VERSION_FILE, 'utf-8').trim();
+                    }
+                }
+                await ctx.logger.info('Checking for updates...');
                 const MAX_RETRIES = 3;
                 let attempt = 0;
                 while (attempt < MAX_RETRIES) {
                     try {
                         const client = createClient(); // Create client with current config
-                        const res = await client.get(`/jobs/${config.jobId}`);
+                        const res = await client.get(`/jobs/${jobId}`);
                         const job = res.data;
                         const newVersion = job.version;
                         // If no version in job yet, fall back to timestamp or ignore
@@ -72,18 +96,18 @@ export const DownloaderPlugin = {
                             let forceDownload = false;
                             const manifestPath = path.join(DIST_DIR, 'manifest.json');
                             if (!fs.existsSync(manifestPath)) {
-                                await ctx.actions.runAction('core:log', { level: 'warn', message: 'Version match but files missing. Forcing download...' });
+                                await ctx.logger.warn('Version match but files missing. Forcing download...');
                                 forceDownload = true;
                             }
                             if (newVersion !== lastModified || forceDownload) {
                                 if (newVersion !== lastModified) {
-                                    await ctx.actions.runAction('core:log', { level: 'info', message: `New version detected (Old: "${lastModified}", New: "${newVersion}")` });
+                                    await ctx.logger.info(`New version detected (Old: "${lastModified}", New: "${newVersion}")`);
                                 }
                                 const success = await ctx.actions.runAction('downloader:download', null);
                                 if (success) {
                                     lastModified = newVersion;
                                     fs.writeFileSync(VERSION_FILE, newVersion);
-                                    ctx.events.emit('downloader:updated', { version: job.version, jobId: config.jobId });
+                                    ctx.events.emit('downloader:updated', { version: job.version, jobId: ctx.config.jobId });
                                 }
                             }
                         }
@@ -97,12 +121,12 @@ export const DownloaderPlugin = {
                         attempt++;
                         const isNetworkError = error.code === 'EAI_AGAIN' || error.code === 'ENOTFOUND' || error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
                         if (attempt < MAX_RETRIES && isNetworkError) {
-                            await ctx.actions.runAction('core:log', { level: 'warn', message: `Connection failed (${error.code}). Retrying (${attempt}/${MAX_RETRIES})...` });
+                            await ctx.logger.warn(`Connection failed (${error.code}). Retrying (${attempt}/${MAX_RETRIES})...`);
                             await new Promise(r => setTimeout(r, 1000 * attempt)); // Backoff
                             continue;
                         }
                         isChecking = false;
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `Check failed: ${error.message}` });
+                        await ctx.logger.error(`Check failed: ${error.message}`);
                         return false;
                     }
                 }
@@ -117,21 +141,22 @@ export const DownloaderPlugin = {
                 const spinner = ora('Downloading new version...').start();
                 try {
                     const client = createClient(); // Create client with current config
-                    const response = await client.get(`/download/${config.jobId}`, {
+                    const { DIST_DIR, DOWNLOAD_PATH, VERSION_FILE } = getPaths();
+                    const response = await client.get(`/download/${ctx.config.jobId}`, {
                         responseType: 'arraybuffer'
                     });
-                    await fs.ensureDir(config.workDir);
+                    await fs.ensureDir(ctx.config.workDir);
                     await fs.writeFile(DOWNLOAD_PATH, response.data);
                     await fs.emptyDir(DIST_DIR);
                     const zip = new AdmZip(DOWNLOAD_PATH);
                     zip.extractAllTo(DIST_DIR, true);
                     // --- HOT RELOAD INJECTION ---
                     try {
-                        // Get dynamically allocated port from ServerPlugin
-                        const hotReloadPort = ctx.hotReloadPort || 3500;
+                        // Get dynamically allocated port from ServerPlugin via config
+                        const hotReloadPort = ctx.config.hotReloadPort || 3500;
                         const HOT_RELOAD_CODE = `
 const EVENT_SOURCE_URL = 'http://localhost:${hotReloadPort}/status';
-const CURRENT_JOB_ID = '${config.jobId}';
+const CURRENT_JOB_ID = '${ctx.config.jobId}';
 let lastVersion = null;
 let lastJobId = null;
 
@@ -174,19 +199,19 @@ console.log('[Hot Reload] Active for Job:', CURRENT_JOB_ID);
                                     const swContent = await fs.readFile(swPath, 'utf-8');
                                     // Prepend import
                                     await fs.writeFile(swPath, "import './hot-reload.js';\n" + swContent);
-                                    await ctx.actions.runAction('core:log', { level: 'info', message: 'Injected Hot Reload script into background worker.' });
+                                    await ctx.logger.info('Injected Hot Reload script into background worker.');
                                 }
                             }
                             // MV2 Scripts Strategy (Fallback if user generates MV2)
                             else if (manifest.background?.scripts) {
                                 manifest.background.scripts.push('hot-reload.js');
                                 await fs.writeJson(manifestPath, manifest, { spaces: 2 });
-                                await ctx.actions.runAction('core:log', { level: 'info', message: 'Injected Hot Reload script into background scripts.' });
+                                await ctx.logger.info('Injected Hot Reload script into background scripts.');
                             }
                         }
                     }
                     catch (injectErr) {
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `Hot Reload Injection Failed: ${injectErr.message}` });
+                        await ctx.logger.error(`Hot Reload Injection Failed: ${injectErr.message}`);
                     }
                     // ----------------------------
                     spinner.succeed('Updated extension code!');
@@ -194,12 +219,13 @@ console.log('[Hot Reload] Active for Job:', CURRENT_JOB_ID);
                 }
                 catch (error) {
                     spinner.fail(`Failed to download: ${error.message}`);
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Download failed: ${error.message}` });
+                    await ctx.logger.error(`Download failed: ${error.message}`);
                     return false;
                 }
             }
         });
         // Polling removed in favor of push-based updates (POST /refresh)
-        ctx.actions.runAction('core:log', { level: 'info', message: 'Ready. Waiting for update signals...' });
+        ctx.logger.info('Ready. Waiting for update signals...');
     }
 };
+export default DownloaderPlugin;

package/dist/plugins/ServerPlugin.js

@@ -1,8 +1,10 @@
 import http from 'http';
-export const ServerPlugin = {
+const ServerPlugin = {
     name: 'server',
     version: '1.0.0',
+    dependencies: ['config'],
     async setup(ctx) {
+        // const context = ctx as PreviewContext; // No longer needed
         let currentVersion = '0.0.0';
         // Try to bind to a port, retrying with incremented ports on failure
         const startPort = 3500;
@@ -13,7 +15,7 @@ export const ServerPlugin = {
         ctx.events.on('downloader:updated', (data) => {
             if (data && data.version) {
                 currentVersion = data.version;
-                ctx.actions.runAction('core:log', { level: 'info', message: `Server: Reporting version ${currentVersion}` });
+                ctx.logger.info(`Server: Reporting version ${currentVersion}`);
             }
         });
         // Create server with request handler
@@ -29,7 +31,7 @@ export const ServerPlugin = {
                 return;
             }
             if (req.url === '/status') {
-                const currentJobId = ctx.host.config.jobId;
+                const currentJobId = ctx.config.jobId;
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
                     version: currentVersion,
@@ -50,8 +52,8 @@ export const ServerPlugin = {
                             const data = JSON.parse(body);
                             if (data.jobId) {
                                 newJobId = data.jobId;
-                                ctx.host.config.jobId = newJobId;
-                                ctx.actions.runAction('core:log', { level: 'info', message: `[API] Switched to new Job ID: ${newJobId}` });
+                                ctx.getRuntime().updateConfig({ jobId: newJobId });
+                                ctx.logger.info(`[API] Switched to new Job ID: ${newJobId}`);
                             }
                         }
                     }
@@ -59,24 +61,24 @@ export const ServerPlugin = {
                         // Ignore parse error
                     }
                     // Trigger manual check
-                    ctx.actions.runAction('core:log', { level: 'info', message: '[API] Refresh request received' });
+                    ctx.logger.info('[API] Refresh request received');
                     ctx.actions.runAction('downloader:check', null).then((result) => {
-                        ctx.actions.runAction('core:log', { level: 'info', message: `[API] Check result: ${result}` });
+                        ctx.logger.info(`[API] Check result: ${result}`);
                     }).catch((err) => {
-                        ctx.actions.runAction('core:log', { level: 'error', message: `[API] Check failed: ${err.message}` });
+                        ctx.logger.error(`[API] Check failed: ${err.message}`);
                     });
                     res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ success: true, jobId: ctx.host.config.jobId }));
+                    res.end(JSON.stringify({ success: true, jobId: ctx.config.jobId }));
                 });
                 return; // Return because we handle response in 'end' callback
             }
             else if (req.url === '/disconnect' && req.method === 'POST') {
                 // Trigger browser stop
-                ctx.actions.runAction('core:log', { level: 'info', message: '[API] Disconnect request received' });
+                ctx.logger.info('[API] Disconnect request received');
                 ctx.actions.runAction('browser:stop', null).then((result) => {
-                    ctx.actions.runAction('core:log', { level: 'info', message: `[API] Browser stop result: ${result}` });
+                    ctx.logger.info(`[API] Browser stop result: ${result}`);
                 }).catch((err) => {
-                    ctx.actions.runAction('core:log', { level: 'error', message: `[API] Browser stop failed: ${err.message}` });
+                    ctx.logger.error(`[API] Browser stop failed: ${err.message}`);
                 });
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ success: true }));
@@ -108,7 +110,7 @@ export const ServerPlugin = {
                 });
                 // Success! Port is allocated
                 allocatedPort = port;
-                await ctx.actions.runAction('core:log', { level: 'info', message: `Hot Reload Server running on port ${allocatedPort}` });
+                await ctx.logger.info(`Hot Reload Server running on port ${allocatedPort}`);
                 break;
             }
             catch (err) {
@@ -122,17 +124,17 @@ export const ServerPlugin = {
                 }
                 else {
                     // Other error, fail immediately
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Server error: ${err.message}` });
+                    await ctx.logger.error(`Server error: ${err.message}`);
                     return;
                 }
             }
         }
         if (!allocatedPort || !server) {
-            await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to allocate port after ${maxAttempts} attempts (ports ${startPort}-${startPort + maxAttempts - 1})` });
+            await ctx.logger.error(`Failed to allocate port after ${maxAttempts} attempts (ports ${startPort}-${startPort + maxAttempts - 1})`);
             return;
         }
         // Store port in context for DownloaderPlugin to use
-        ctx.hotReloadPort = allocatedPort;
+        ctx.getRuntime().updateConfig({ hotReloadPort: allocatedPort });
         // Store server instance to close later
         ctx._serverInstance = server;
     },
@@ -143,3 +145,4 @@ export const ServerPlugin = {
         }
     }
 };
+export default ServerPlugin;

package/dist/plugins/browser/BrowserManagerPlugin.js

@@ -1,46 +1,64 @@
 import path from 'path';
 import fs from 'fs-extra';
 import { findExtensionRoot, validateExtension } from '../../utils/browserUtils.js';
-export const BrowserManagerPlugin = {
+const BrowserManagerPlugin = {
     name: 'browser-manager',
     version: '1.0.0',
+    dependencies: ['config', 'downloader'],
     setup(ctx) {
-        const config = ctx.host.config;
-        const DIST_DIR = path.join(config.workDir, 'dist');
-        // --- Centralized Path Strategy ---
-        const isWSL = fs.existsSync('/mnt/c');
-        const isWin = process.platform === 'win32';
-        // Unified Staging Path (C:\\Temp for Windows/WSL, local for others)
-        const STAGING_DIR = isWSL
-            ? '/mnt/c/Temp/ai-ext-preview'
-            : (isWin ? 'C:\\Temp\\ai-ext-preview' : path.join(config.workDir, '../staging'));
+        // Helper to get dynamic paths
+        const getPaths = () => {
+            const config = ctx.config;
+            const DIST_DIR = path.join(config.workDir, 'dist');
+            const isWSL = fs.existsSync('/mnt/c');
+            const isWin = process.platform === 'win32';
+            const STAGING_DIR = isWSL
+                ? '/mnt/c/Temp/ai-ext-preview'
+                : (isWin ? 'C:\\Temp\\ai-ext-preview' : path.join(config.workDir, '../staging'));
+            return { DIST_DIR, STAGING_DIR };
+        };
         // --- SYNC FUNCTION ---
         const syncToStaging = async () => {
+            const { DIST_DIR, STAGING_DIR } = getPaths();
             try {
                 if (fs.existsSync(STAGING_DIR)) {
                     fs.emptyDirSync(STAGING_DIR);
                 }
                 fs.ensureDirSync(STAGING_DIR);
                 fs.copySync(DIST_DIR, STAGING_DIR);
-                await ctx.actions.runAction('core:log', { level: 'info', message: `Synced code to Staging` });
+                await ctx.logger.info(`Synced code to Staging`);
                 // Emit staged event (optional)
                 ctx.events.emit('browser:staged', { path: STAGING_DIR });
             }
             catch (err) {
-                await ctx.actions.runAction('core:log', { level: 'error', message: `Failed to sync to staging: ${err.message}` });
+                await ctx.logger.error(`Failed to sync to staging: ${err.message}`);
             }
         };
         const launchBrowser = async () => {
+            const { STAGING_DIR } = getPaths();
             // Resolve proper root AFTER sync
             const extensionRoot = findExtensionRoot(STAGING_DIR) || STAGING_DIR;
-            // Validate
+            // 1. Static Validation
             const validation = validateExtension(extensionRoot);
             if (!validation.valid) {
-                await ctx.actions.runAction('core:log', { level: 'error', message: `[CRITICAL] Extension validation failed: ${validation.error} in ${extensionRoot}` });
+                await ctx.logger.error(`[CRITICAL] Extension validation failed: ${validation.error} in ${extensionRoot}`);
             }
             else if (extensionRoot !== STAGING_DIR) {
-                await ctx.actions.runAction('core:log', { level: 'info', message: `Detected nested extension at: ${path.basename(extensionRoot)}` });
+                await ctx.logger.info(`Detected nested extension at: ${path.basename(extensionRoot)}`);
+            }
+            // 2. Runtime Verification (Diagnostic) - SKIPPED FOR PERFORMANCE
+            // The SandboxRunner spins up a separate headless chrome which is slow and prone to WSL networking issues.
+            // Since we have static analysis in the backend, we skip this blocking step to give the user immediate feedback.
+            /*
+            await ctx.actions.runAction('core:log', { level: 'info', message: 'Running diagnostic verification...' });
+            const diagResult = await SandboxRunner.validateExtensionRuntime(extensionRoot);
+
+            if (diagResult.success) {
+                await ctx.actions.runAction('core:log', { level: 'info', message: '✅ Diagnostic Verification Passed.' });
+            } else {
+                await ctx.actions.runAction('core:log', { level: 'error', message: `❌ Diagnostic Verification Failed: ${diagResult.error}` });
             }
+            */
             // Delegate Launch
             // We pass the filesystem path (STAGING_DIR or extensionRoot)
             // The specific Launcher plugin handles environment specific path verification/conversion
@@ -64,7 +82,7 @@ export const BrowserManagerPlugin = {
         ctx.actions.registerAction({
             id: 'browser:stop',
             handler: async () => {
-                await ctx.actions.runAction('core:log', { level: 'info', message: 'Stopping browser...' });
+                await ctx.logger.info('Stopping browser...');
                 const result = await ctx.actions.runAction('launcher:kill', null);
                 return result;
             }
@@ -72,21 +90,24 @@ export const BrowserManagerPlugin = {
         // Event: Update detected
         ctx.events.on('downloader:updated', async () => {
             if (isInitialized) {
-                await ctx.actions.runAction('core:log', { level: 'info', message: 'Update detected. Restarting browser...' });
+                await ctx.logger.info('Update detected. Restarting browser...');
                 try {
                     await ctx.actions.runAction('browser:stop', {});
                 }
                 catch (e) {
                     // Ignore if already stopped
                 }
+                // [Optimization] Wait for process cleanup to avoid "Open in new tab" race condition
+                await new Promise(r => setTimeout(r, 1000));
                 await ctx.actions.runAction('browser:start', {});
             }
         });
         // Event: Browser closed (from launcher)
         ctx.events.on('browser:closed', async (data) => {
-            await ctx.actions.runAction('core:log', { level: 'info', message: `Browser closed with code ${data.code}` });
+            await ctx.logger.info(`Browser closed with code ${data.code}`);
             // Emit event that can be picked up by other plugins (e.g., to notify backend)
             ctx.events.emit('session:terminated', { reason: 'browser_closed' });
         });
     }
 };
+export default BrowserManagerPlugin;

package/dist/plugins/browser/NativeLauncherPlugin.js

@@ -3,9 +3,10 @@ import fs from 'fs-extra';
 import { spawn } from 'child_process';
 import { findChrome, normalizePathToWindows } from '../../utils/browserUtils.js';
 let chromeProcess = null;
-export const NativeLauncherPlugin = {
+const NativeLauncherPlugin = {
     name: 'native-launcher',
     version: '1.0.0',
+    dependencies: ['config'],
     setup(ctx) {
         // Only active if NOT in WSL
         const isWSL = fs.existsSync('/mnt/c');
@@ -14,7 +15,7 @@ export const NativeLauncherPlugin = {
         ctx.actions.registerAction({
             id: 'launcher:launch',
             handler: async (payload) => {
-                const config = ctx.host.config;
+                const config = ctx.config;
                 const chromePath = findChrome();
                 if (!chromePath) {
                     await ctx.actions.runAction('core:log', { level: 'error', message: 'Chrome not found.' });
@@ -55,14 +56,14 @@ export const NativeLauncherPlugin = {
                     });
                     // Monitor process exit
                     chromeProcess.on('exit', async (code) => {
-                        await ctx.actions.runAction('core:log', { level: 'info', message: `Chrome exited with code ${code} ` });
+                        ctx.logger.info(`[NativeLauncher] Chrome exited with code ${code}`);
                         chromeProcess = null;
                         ctx.events.emit('browser:closed', { code });
                     });
-                    await ctx.actions.runAction('core:log', { level: 'info', message: `Chrome launched with PID: ${chromeProcess.pid} ` });
+                    ctx.logger.info('[NativeLauncher] Chrome started with PID: ' + chromeProcess.pid);
                 }
                 catch (spawnErr) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `Spawn Failed: ${spawnErr.message} ` });
+                    ctx.logger.error(`[NativeLauncher] Spawn Failed: ${spawnErr.message}`);
                     return false;
                 }
                 return true;
@@ -73,7 +74,7 @@ export const NativeLauncherPlugin = {
             id: 'launcher:kill',
             handler: async () => {
                 if (chromeProcess) {
-                    await ctx.actions.runAction('core:log', { level: 'info', message: 'Terminating Chrome process...' });
+                    ctx.logger.info('[NativeLauncher] Chrome process force killed.');
                     chromeProcess.kill();
                     chromeProcess = null;
                     return true;
@@ -89,3 +90,4 @@ export const NativeLauncherPlugin = {
         }
     }
 };
+export default NativeLauncherPlugin;

package/dist/plugins/browser/WSLLauncherPlugin.js

@@ -3,9 +3,10 @@ import fs from 'fs-extra';
 import { spawn } from 'child_process';
 import { findChrome } from '../../utils/browserUtils.js';
 let chromePid = null;
-export const WSLLauncherPlugin = {
+const WSLLauncherPlugin = {
     name: 'wsl-launcher',
     version: '1.0.0',
+    dependencies: ['config'],
     setup(ctx) {
         // Only active in WSL
         const isWSL = fs.existsSync('/mnt/c');
@@ -16,7 +17,7 @@ export const WSLLauncherPlugin = {
             handler: async (payload) => {
                 const chromePath = findChrome();
                 if (!chromePath) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: 'Chrome not found for detached launch.' });
+                    await ctx.logger.error('Chrome not found for detached launch.');
                     return false;
                 }
                 // Hardcoded Safe Paths for WSL Strategy
@@ -36,7 +37,7 @@ export const WSLLauncherPlugin = {
                 const winChromePath = chromePath
                     .replace(new RegExp(`^/mnt/${driveLetter}/`), `${driveLetter.toUpperCase()}:\\\\`)
                     .replace(/\//g, '\\\\');
-                await ctx.actions.runAction('core:log', { level: 'info', message: `WSL Launch Target (Win): ${finalWinExtensionPath}` });
+                await ctx.logger.info(`WSL Launch Target (Win): ${finalWinExtensionPath}`);
                 // Create PowerShell Launch Script with PID capture
                 const psContent = `
 $chromePath = "${winChromePath}"
@@ -73,7 +74,7 @@ Write-Host "CHROME_PID:$($process.Id)"
                     await fs.writeFile(psPath, psContent);
                 }
                 catch (e) {
-                    await ctx.actions.runAction('core:log', { level: 'error', message: `WSL Write PS1 Failed: ${e.message}` });
+                    await ctx.logger.error(`WSL Write PS1 Failed: ${e.message}`);
                     return false;
                 }
                 // Execute via PowerShell
@@ -89,11 +90,11 @@ Write-Host "CHROME_PID:$($process.Id)"
                         const pidMatch = msg.match(/CHROME_PID:(\d+)/);
                         if (pidMatch) {
                             chromePid = parseInt(pidMatch[1], 10);
-                            await ctx.actions.runAction('core:log', { level: 'info', message: `Chrome launched with PID: ${chromePid}` });
+                            await ctx.logger.info(`Chrome launched with PID: ${chromePid}`);
                             // Start monitoring the process
                             monitorProcess(ctx, chromePid);
                         }
-                        await ctx.actions.runAction('core:log', { level: 'info', message: `[PS1] ${msg.trim()}` });
+                        await ctx.logger.info(`[PS1] ${msg.trim()}`);
                     });
                 }
                 if (child.stderr) {
@@ -101,10 +102,10 @@ Write-Host "CHROME_PID:$($process.Id)"
                         const msg = chunk.toString();
                         // Ignore minor PS noise unless critical
                         if (msg.includes('Exec format error')) {
-                            await ctx.actions.runAction('core:log', { level: 'error', message: `CRITICAL: WSL Interop broken.` });
+                            await ctx.logger.error(`CRITICAL: WSL Interop broken.`);
                         }
                         else if (msg.trim()) {
-                            await ctx.actions.runAction('core:log', { level: 'error', message: `Launch Error: ${msg}` });
+                            await ctx.logger.error(`Launch Error: ${msg}`);
                         }
                     });
                 }
@@ -116,25 +117,43 @@ Write-Host "CHROME_PID:$($process.Id)"
             id: 'launcher:kill',
             handler: async () => {
                 if (chromePid) {
-                    await ctx.actions.runAction('core:log', { level: 'info', message: `Terminating Chrome process (PID: ${chromePid})...` });
+                    await ctx.logger.info(`Terminating Chrome process (PID: ${chromePid})...`);
                     try {
-                        // Use taskkill via PowerShell
-                        const killChild = spawn('powershell.exe', ['-Command', `Stop-Process -Id ${chromePid} -Force`], {
-                            stdio: 'ignore'
-                        });
-                        killChild.on('exit', async (code) => {
-                            if (code === 0) {
-                                await ctx.actions.runAction('core:log', { level: 'info', message: 'Chrome process terminated successfully.' });
-                                chromePid = null;
-                            }
-                            else {
-                                await ctx.actions.runAction('core:log', { level: 'warn', message: `taskkill exited with code ${code}` });
+                        // 1. Try Stop-Process first (Graceful)
+                        const killCmd = `
+                            $targetPid = ${chromePid}
+                            try { 
+                                Stop-Process -Id $targetPid -Force -ErrorAction Stop
+                                Write-Host "STOPPED"
+                            } catch {
+                                try {
+                                    taskkill.exe /F /PID $targetPid
+                                    Write-Host "TASKKILLED"
+                                } catch {
+                                    Write-Host "FAILED: $_" 
+                                    exit 1
+                                }
                             }
+                        `;
+                        const killChild = spawn('powershell.exe', ['-Command', killCmd], { stdio: 'pipe' });
+                        // Capture output to debug why it might fail
+                        if (killChild.stdout) {
+                            killChild.stdout.on('data', d => ctx.logger.debug(`[KillParams] ${d}`));
+                        }
+                        if (killChild.stderr) {
+                            killChild.stderr.on('data', d => ctx.logger.warn(`[KillMsg] ${d}`));
+                        }
+                        await new Promise((resolve) => {
+                            killChild.on('exit', (code) => {
+                                resolve();
+                            });
                         });
+                        await ctx.logger.info('Chrome process termination signal sent.');
+                        chromePid = null;
                         return true;
                     }
                     catch (err) {
-                        await ctx.actions.runAction('core:log', { level: 'error', message: `Kill failed: ${err.message}` });
+                        await ctx.logger.error(`Kill failed: ${err.message}`);
                         return false;
                     }
                 }
@@ -158,7 +177,7 @@ Write-Host "CHROME_PID:$($process.Id)"
                         if (!output.trim() || code !== 0) {
                             // Process no longer exists
                             clearInterval(checkInterval);
-                            await ctx.actions.runAction('core:log', { level: 'info', message: 'Chrome process exited.' });
+                            await ctx.logger.info('Chrome process exited.');
                             chromePid = null;
                             ctx.events.emit('browser:closed', { code: 0 });
                         }
@@ -178,3 +197,4 @@ Write-Host "CHROME_PID:$($process.Id)"
         }
     }
 };
+export default WSLLauncherPlugin;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/sandbox.js

@@ -0,0 +1,192 @@
+import puppeteer from 'puppeteer-core';
+import path from 'path';
+import fs from 'fs-extra';
+import { spawn, execSync } from 'child_process';
+import axios from 'axios';
+import { findChrome } from './browserUtils.js';
+export class SandboxRunner {
+    /**
+     * Launch a headless browser with the extension loaded to verify it can initialize.
+     * @param extensionPath Absolute path to the unpacked extension directory
+     * @param chromePath Optional path to Chrome executable. If not provided, attempts to auto-detect.
+     */
+    static async validateExtensionRuntime(extensionPath, chromePath) {
+        const logs = [];
+        const executablePath = chromePath || findChrome();
+        if (!executablePath) {
+            return {
+                success: false,
+                logs,
+                error: 'Chrome executable not found. Cannot run verification.'
+            };
+        }
+        const isWSL = executablePath.startsWith('/mnt/');
+        if (isWSL) {
+            logs.push('[Sandbox] WSL Environment detected. Using "Spawn & Connect" strategy.');
+            return this.runWSLCheck(extensionPath, executablePath, logs);
+        }
+        else {
+            return this.runStandardCheck(extensionPath, executablePath, logs);
+        }
+    }
+    static async runStandardCheck(extensionPath, executablePath, logs) {
+        let browser;
+        try {
+            logs.push(`[Sandbox] Launching standard verification for: ${extensionPath}`);
+            logs.push(`[Sandbox] Using Chrome at: ${executablePath}`);
+            browser = await puppeteer.launch({
+                headless: true,
+                executablePath: executablePath,
+                args: [
+                    `--disable-extensions-except=${extensionPath}`,
+                    `--load-extension=${extensionPath}`,
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox'
+                ]
+            });
+            return await this.performChecks(browser, extensionPath, logs);
+        }
+        catch (error) {
+            console.error('[Sandbox] Standard Launch Error:', error);
+            return { success: false, logs, error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            if (browser)
+                await browser.close();
+        }
+    }
+    static async runWSLCheck(extensionPath, linuxChromePath, logs) {
+        let browser;
+        let chromePid = null;
+        try {
+            // 1. Path Conversion (Linux -> Windows)
+            const driveMatch = linuxChromePath.match(/^\/mnt\/([a-z])\//);
+            if (!driveMatch)
+                throw new Error(`Could not parse drive letter from ${linuxChromePath}`);
+            const driveLetter = driveMatch[1];
+            const winChromePath = linuxChromePath
+                .replace(new RegExp(`^/mnt/${driveLetter}/`), `${driveLetter.toUpperCase()}:\\`)
+                .replace(/\//g, '\\');
+            // 1b. Detect Host IP (WSL DNS Resolver IP)
+            let hostIp = '127.0.0.1';
+            try {
+                const resolveConf = fs.readFileSync('/etc/resolv.conf', 'utf-8');
+                const match = resolveConf.match(/nameserver\s+([\d.]+)/);
+                if (match)
+                    hostIp = match[1];
+                logs.push(`[Sandbox] Host IP detected: ${hostIp}`);
+            }
+            catch (e) {
+                logs.push(`[Sandbox] Failed to detect Host IP, fallback to 127.0.0.1: ${e}`);
+            }
+            let winExtensionPath = extensionPath;
+            const extDriveMatch = extensionPath.match(/^\/mnt\/([a-z])\//);
+            if (extDriveMatch) {
+                winExtensionPath = extensionPath
+                    .replace(new RegExp(`^/mnt/${extDriveMatch[1]}/`), `${extDriveMatch[1].toUpperCase()}:\\`)
+                    .replace(/\//g, '\\');
+            }
+            else {
+                logs.push('[Sandbox] WARNING: Extension path is not in /mnt/. Windows Chrome might not see it.');
+            }
+            // 2. Spawn Chrome via PowerShell
+            const port = 9222;
+            const winProfile = `C:\\Temp\\ai-ext-sandbox-${Date.now()}`;
+            const args = [
+                `--headless=new`,
+                `--disable-extensions-except="${winExtensionPath}"`,
+                `--load-extension="${winExtensionPath}"`,
+                `--user-data-dir="${winProfile}"`,
+                '--no-sandbox',
+                '--disable-gpu',
+                '--disable-dev-shm-usage',
+                '--no-first-run',
+                '--no-default-browser-check',
+                `--remote-debugging-port=${port}`,
+                `--remote-debugging-address=0.0.0.0`, // Bind to all interfaces so WSL can see it
+                `--remote-allow-origins=*` // Allow puppeteer connection
+            ];
+            const psCommand = `Start-Process -FilePath "${winChromePath}" -ArgumentList '${args.join(' ')}' -PassThru`;
+            logs.push(`[Sandbox] Spawning Chrome via PowerShell on port ${port}...`);
+            logs.push(`[Sandbox] Profile: ${winProfile}`);
+            const child = spawn('powershell.exe', ['-Command', psCommand], { stdio: 'pipe' });
+            await new Promise((resolve, reject) => {
+                child.stdout.on('data', (data) => {
+                    const output = data.toString();
+                    const match = output.match(/\s+(\d+)\s+\d+\s+chrome/i) || output.match(/Id\s+:\s+(\d+)/);
+                    if (match) {
+                        chromePid = parseInt(match[1], 10);
+                        logs.push(`[Sandbox] Chrome PID: ${chromePid}`);
+                    }
+                });
+                child.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`PowerShell exited with code ${code}`));
+                });
+            });
+            // 3. Wait for Port
+            logs.push('[Sandbox] Waiting for Chrome to accept connections...');
+            let connected = false;
+            // Increased timeout to 15s (30 * 500ms)
+            for (let i = 0; i < 30; i++) {
+                try {
+                    // Use hostIp, not localhost
+                    await axios.get(`http://${hostIp}:${port}/json/version`, { timeout: 1000 });
+                    connected = true;
+                    break;
+                }
+                catch (e) {
+                    await new Promise(r => setTimeout(r, 500));
+                }
+            }
+            if (!connected)
+                throw new Error(`Timed out waiting for Chrome debug port ${port}`);
+            // 4. Connect Puppeteer
+            logs.push('[Sandbox] Connecting Puppeteer...');
+            browser = await puppeteer.connect({
+                browserURL: `http://${hostIp}:${port}`
+            });
+            // 5. Perform Checks
+            const result = await this.performChecks(browser, extensionPath, logs);
+            return result;
+        }
+        catch (error) {
+            console.error('[Sandbox] WSL Check Error:', error);
+            return { success: false, logs, error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            if (browser)
+                await browser.disconnect();
+            if (chromePid) {
+                logs.push(`[Sandbox] Killing Chrome PID ${chromePid}...`);
+                try {
+                    execSync(`powershell.exe -Command "Stop-Process -Id ${chromePid} -Force"`);
+                }
+                catch (e) { /* ignore */ }
+            }
+        }
+    }
+    static async performChecks(browser, extensionPath, logs) {
+        await new Promise(r => setTimeout(r, 2000));
+        const targets = await browser.targets();
+        const backgroundTarget = targets.find(t => t.type() === 'service_worker' || t.type() === 'background_page');
+        if (!backgroundTarget) {
+            const manifestPath = path.join(extensionPath, 'manifest.json');
+            if (fs.existsSync(manifestPath)) {
+                const manifest = await fs.readJson(manifestPath);
+                if (manifest.background) {
+                    return { success: false, logs, error: 'Background Service Worker defined in manifest but failed to start.' };
+                }
+                else {
+                    logs.push('[Sandbox] No background script defined in manifest. Skipping worker check.');
+                }
+            }
+        }
+        else {
+            logs.push('Background worker started successfully.');
+        }
+        return { success: true, logs };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-extension-preview",
-    "version": "0.1.14",
+    "version": "0.1.16",
     "description": "Local preview tool for AI Extension Builder",
     "type": "module",
     "bin": {
@@ -37,9 +37,10 @@
         "node-fetch": "^3.3.2",
         "ora": "^8.1.1",
         "puppeteer-core": "^24.33.0",
-        "skeleton-crew-runtime": "^0.1.5",
+        "skeleton-crew-runtime": "^0.2.1",
         "web-ext": "^8.3.0",
-        "ws": "^8.18.0"
+        "ws": "^8.18.0",
+        "zod": "^4.2.1"
     },
     "devDependencies": {
         "@types/adm-zip": "^0.5.6",