vg-coder-cli 2.0.46 → 2.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.46",
+  "version": "2.0.47",
   "description": "🚀 CLI tool to analyze projects, concatenate source files, count tokens, and export HTML with syntax highlighting and copy functionality",
   "main": "src/index.js",
   "bin": {
@@ -45,6 +45,7 @@
     "ignore": "^5.3.0",
     "markdown-it": "^14.0.0",
     "mermaid": "^11.4.1",
+    "multer": "^1.4.5-lts.1",
     "node-pty": "^1.1.0",
     "ora": "^5.4.1",
     "path": "^0.12.7",

package/src/server/api-server.js

@@ -17,6 +17,9 @@ const TokenManager = require('../tokenizer/token-manager');
 const BashExecutor = require('../utils/bash-executor');
 const terminalManager = require('./terminal-manager');
 const projectManager = require('./project-manager');
+const taskQueue = require('./task-queue');
+const taskStore = require('./task-store');
+const multer = require('multer');
 
 class ApiServer {
   constructor(port = 6868) {
@@ -32,6 +35,19 @@ class ApiServer {
   }
 
   setupMiddleware() {
+    // Private Network Access — Chrome 130+ requires this header for HTTPS
+    // origins (e.g. aistudio.google.com) calling localhost.
+    this.app.use((req, res, next) => {
+        res.setHeader('Access-Control-Allow-Private-Network', 'true');
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Origin', req.headers.origin || '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', req.headers['access-control-request-headers'] || 'Content-Type, Authorization');
+            res.setHeader('Access-Control-Max-Age', '600');
+            return res.sendStatus(204);
+        }
+        next();
+    });
     this.app.use(cors());
     this.app.use(bodyParser.json({ limit: '50mb' }));
     this.app.use(bodyParser.urlencoded({ extended: true, limit: '50mb' }));
@@ -47,6 +63,7 @@ class ApiServer {
   }
 
   setupSocketIO() {
+    taskQueue.attachIO(this.io);
     this.io.on('connection', (socket) => {
         socket.on('terminal:init', (data) => {
             if (!data || !data.termId) return;
@@ -65,7 +82,26 @@ class ApiServer {
         socket.on('terminal:input', (data) => { if (data && data.termId) terminalManager.write(data.termId, data.data); });
         socket.on('terminal:resize', (data) => { if (data && data.termId) terminalManager.resize(data.termId, data.cols, data.rows); });
         socket.on('terminal:kill', (data) => { if (data && data.termId) terminalManager.kill(data.termId); });
-        socket.on('disconnect', () => { terminalManager.cleanupSocket(socket.id); });
+
+        // Task worker registration & lifecycle
+        socket.on('worker:register', (meta) => { taskQueue.setWorker(socket, meta || {}); });
+        socket.on('worker:heartbeat', () => { /* keep-alive only */ });
+        socket.on('task:complete', (payload) => {
+            if (payload?.taskId) taskQueue.onWorkerComplete(payload.taskId, payload, socket.id);
+        });
+        socket.on('task:failed', (payload) => {
+            if (payload?.taskId) taskQueue.onWorkerFailed(payload.taskId, { code: payload.code, message: payload.message }, socket.id);
+        });
+        socket.on('task:progress', () => { /* ignored for now */ });
+
+        // Profile launcher (extension background SW). One per Chrome profile.
+        socket.on('launcher:register', (meta) => { taskQueue.setLauncher(socket, meta || {}); });
+
+        socket.on('disconnect', () => {
+            terminalManager.cleanupSocket(socket.id);
+            taskQueue.clearWorker(socket);
+            taskQueue.clearLauncher(socket);
+        });
     });
   }
 
@@ -408,6 +444,306 @@ class ApiServer {
         } catch (error) { res.status(500).json({ error: error.message }); }
     });
 
+    // Chat History (per-project, stored in .vg/chats/<id>.json)
+    const chatsDir = (workingDir) => path.join(workingDir, '.vg', 'chats');
+    const sanitizeChatId = (id) => String(id || '').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 200);
+
+    this.app.get('/api/chats', async (req, res) => {
+        try {
+            const dir = chatsDir(req.workingDir);
+            if (!await fs.pathExists(dir)) return res.json({ chats: [] });
+            const files = (await fs.readdir(dir)).filter(f => f.endsWith('.json'));
+            const chats = [];
+            for (const f of files) {
+                try {
+                    const data = await fs.readJson(path.join(dir, f));
+                    chats.push({
+                        id: data.id,
+                        title: data.title || '(untitled)',
+                        source: data.source || 'unknown',
+                        createdAt: data.createdAt,
+                        updatedAt: data.updatedAt,
+                        count: Array.isArray(data.messages) ? data.messages.length : 0
+                    });
+                } catch (_) { /* skip corrupt file */ }
+            }
+            chats.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+            res.json({ chats });
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.get('/api/chats/:id', async (req, res) => {
+        try {
+            const id = sanitizeChatId(req.params.id);
+            const file = path.join(chatsDir(req.workingDir), `${id}.json`);
+            if (!await fs.pathExists(file)) return res.status(404).json({ error: 'Chat not found' });
+            res.json(await fs.readJson(file));
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.post('/api/chats/:id', async (req, res) => {
+        try {
+            const id = sanitizeChatId(req.params.id);
+            if (!id) return res.status(400).json({ error: 'Invalid chat id' });
+            const dir = chatsDir(req.workingDir);
+            await fs.ensureDir(dir);
+            const file = path.join(dir, `${id}.json`);
+            const now = Date.now();
+            const incoming = req.body || {};
+            const existing = await fs.pathExists(file) ? await fs.readJson(file) : null;
+            const data = {
+                id,
+                source: incoming.source || existing?.source || 'unknown',
+                title: incoming.title || existing?.title || '(untitled)',
+                createdAt: existing?.createdAt || now,
+                updatedAt: now,
+                messages: Array.isArray(incoming.messages) ? incoming.messages : (existing?.messages || [])
+            };
+            await fs.writeJson(file, data, { spaces: 2 });
+            res.json({ success: true, id, count: data.messages.length });
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.delete('/api/chats/:id', async (req, res) => {
+        try {
+            const id = sanitizeChatId(req.params.id);
+            const file = path.join(chatsDir(req.workingDir), `${id}.json`);
+            if (await fs.pathExists(file)) await fs.remove(file);
+            res.json({ success: true });
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    // ---------------- Remote Task API ----------------
+    const taskUpload = multer({
+      storage: multer.diskStorage({
+        destination: (req, file, cb) => {
+          // Stage uploads in a per-request temp dir; we move into final task dir after id assigned
+          const tmpDir = path.join(req.workingDir, '.vg', 'tasks', '_uploads', String(Date.now()) + '_' + Math.random().toString(36).slice(2, 8));
+          fs.ensureDir(tmpDir).then(() => cb(null, tmpDir)).catch(cb);
+          req._taskTmpDir = req._taskTmpDir || tmpDir;
+        },
+        filename: (req, file, cb) => cb(null, `${Date.now()}__${file.originalname}`)
+      }),
+      limits: { fileSize: 50 * 1024 * 1024, files: 10 }
+    });
+
+    this.app.post('/api/tasks', taskUpload.array('files', 10), async (req, res) => {
+        try {
+            const prompt = (req.body?.prompt || '').toString();
+            if (!prompt && (!req.files || req.files.length === 0)) {
+                return res.status(400).json({ error: 'prompt or files required' });
+            }
+            let meta = null;
+            if (req.body?.meta) {
+                try { meta = JSON.parse(req.body.meta); } catch (_) { meta = req.body.meta; }
+            }
+            const webhookUrl = req.body?.webhookUrl ? String(req.body.webhookUrl) : null;
+            const workerLabel = req.body?.workerLabel
+                ? String(req.body.workerLabel).toLowerCase().trim()
+                : null;
+
+            const id = taskStore.newTaskId();
+            const finalDir = taskStore.taskDir(req.workingDir, id);
+            const finalFiles = path.join(finalDir, 'files');
+            await fs.ensureDir(finalFiles);
+
+            const fileEntries = [];
+            for (let i = 0; i < (req.files || []).length; i++) {
+                const f = req.files[i];
+                const safeName = path.basename(f.originalname).replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 120) || `file_${i}`;
+                const dest = path.join(finalFiles, `${i}__${safeName}`);
+                await fs.move(f.path, dest, { overwrite: true });
+                fileEntries.push({ idx: i, name: f.originalname, mime: f.mimetype, size: f.size, path: dest });
+            }
+            // Cleanup tmp dir
+            if (req._taskTmpDir) {
+                try { await fs.remove(req._taskTmpDir); } catch (_) {}
+            }
+
+            const task = {
+                id,
+                status: 'queued',
+                prompt,
+                meta,
+                files: fileEntries,
+                webhookUrl,
+                webhook: { attempts: [], deliveredAt: null },
+                worker: null,
+                workerLabel,
+                attempts: [],
+                result: null,
+                error: null,
+                timing: { createdAt: Date.now() },
+                cancelRequestedAt: null,
+                workingDir: req.workingDir
+            };
+
+            const result = await taskQueue.enqueue(task);
+            res.status(202).json({
+                taskId: id,
+                status: result.status,
+                position: result.position,
+                pollUrl: `/api/tasks/${id}`,
+                createdAt: task.timing.createdAt
+            });
+        } catch (error) {
+            console.error('[Tasks] create failed:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+
+    this.app.get('/api/tasks', async (req, res) => {
+        try {
+            const filter = {};
+            if (req.query.status) filter.status = String(req.query.status);
+            if (req.query.limit) filter.limit = Math.min(parseInt(req.query.limit, 10) || 50, 500);
+            res.json({ tasks: await taskQueue.list(req.workingDir, filter) });
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.get('/api/tasks/:id', async (req, res) => {
+        try {
+            const id = taskStore.sanitizeTaskId(req.params.id);
+            const task = await taskQueue.get(id, req.workingDir);
+            if (!task) return res.status(404).json({ error: 'Task not found' });
+            const result = { ...task };
+            if (task.status === 'done') {
+                result.result = { ...(task.result || {}), markdown: await taskStore.readResult(task.workingDir, task.id) };
+            }
+            res.json(result);
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.delete('/api/tasks/:id', async (req, res) => {
+        try {
+            const id = taskStore.sanitizeTaskId(req.params.id);
+            const r = await taskQueue.cancel(id, req.workingDir);
+            if (!r.ok) return res.status(r.code || 400).json({ error: 'cannot_cancel', status: r.status });
+            res.json({ canceled: true, status: r.status });
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+
+    this.app.get('/api/tasks/:id/files/:idx', async (req, res) => {
+        try {
+            const id = taskStore.sanitizeTaskId(req.params.id);
+            const idx = parseInt(req.params.idx, 10);
+            if (!Number.isInteger(idx) || idx < 0) return res.status(400).json({ error: 'invalid idx' });
+            const task = await taskQueue.get(id, req.workingDir);
+            if (!task) return res.status(404).json({ error: 'task not found' });
+            const file = (task.files || []).find(f => f.idx === idx);
+            if (!file || !file.path) return res.status(404).json({ error: 'file not found' });
+            if (!await fs.pathExists(file.path)) return res.status(404).json({ error: 'file missing on disk' });
+            res.setHeader('Content-Type', file.mime || 'application/octet-stream');
+            res.setHeader('Content-Disposition', `inline; filename="${encodeURIComponent(file.name)}"`);
+            fs.createReadStream(file.path).pipe(res);
+        } catch (error) { res.status(500).json({ error: error.message }); }
+    });
+    // ---------------- /Remote Task API ----------------
+
+    // ---------------- Remote Debug API ----------------
+    // Localhost-only debug surface for connected AI Studio workers.
+    // Pass `workerLabel` (email) in query/body to target a specific worker.
+
+    // Helper: extract worker target from query/body
+    const workerOpts = (req) => {
+        const label = (req.query?.label || req.query?.workerLabel || req.body?.workerLabel || '').toString().toLowerCase().trim();
+        return label ? { workerLabel: label } : {};
+    };
+
+    this.app.get('/api/workers', (req, res) => {
+        res.json({ workers: taskQueue.listWorkers() });
+    });
+
+    this.app.get('/api/launchers', (req, res) => {
+        res.json({ launchers: taskQueue.listLaunchers() });
+    });
+
+    // List AI Studio tabs across all profiles (or 1 if workerLabel given).
+    this.app.get('/api/launcher/tabs', async (req, res) => {
+        try {
+            const label = (req.query?.label || req.query?.workerLabel || '').toString().trim();
+            const opts = label ? { workerLabel: label } : { all: true };
+            const result = await taskQueue.requestLauncher('launcher:list_tabs', {}, opts, 5_000);
+            res.json(result);
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    // Close tab(s). Body: { workerLabel?, tabId? } — omit tabId to close all.
+    this.app.post('/api/launcher/close-tab', async (req, res) => {
+        try {
+            const body = req.body || {};
+            const opts = body.workerLabel ? { workerLabel: body.workerLabel } : (body.all ? { all: true } : {});
+            const payload = body.tabId != null ? { tabId: body.tabId } : {};
+            const result = await taskQueue.requestLauncher('launcher:close_tab', payload, opts, 5_000);
+            res.json(result);
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    // Open new AI Studio tab. Body: { workerLabel?, model?, url?, active? }
+    this.app.post('/api/launcher/open-tab', async (req, res) => {
+        try {
+            const body = req.body || {};
+            const opts = body.workerLabel ? { workerLabel: body.workerLabel } : {};
+            const payload = { url: body.url, model: body.model, active: body.active };
+            const result = await taskQueue.requestLauncher('launcher:open_tab', payload, opts, 8_000);
+            res.json(result);
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.get('/api/worker/status', (req, res) => {
+        const label = (req.query?.label || req.query?.workerLabel || '').toString().toLowerCase().trim();
+        res.json(taskQueue.workerStatus(label || undefined));
+    });
+
+    this.app.get('/api/worker/url', async (req, res) => {
+        try { res.json(await taskQueue.requestWorker('debug:url', {}, workerOpts(req))); }
+        catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.post('/api/worker/probe', async (req, res) => {
+        try {
+            const { selector, kind } = req.body || {};
+            if (!selector) return res.status(400).json({ error: 'selector required' });
+            res.json(await taskQueue.requestWorker('debug:probe', { selector, kind: kind || 'text' }, workerOpts(req)));
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.post('/api/worker/dom', async (req, res) => {
+        try {
+            const { selector, maxBytes } = req.body || {};
+            res.json(await taskQueue.requestWorker('debug:dom', { selector, maxBytes: maxBytes || 200_000 }, workerOpts(req)));
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.post('/api/worker/eval', async (req, res) => {
+        try {
+            const { code, timeoutMs } = req.body || {};
+            if (!code) return res.status(400).json({ error: 'code required' });
+            res.json(await taskQueue.requestWorker('debug:eval', { code }, workerOpts(req), timeoutMs || 15_000));
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.post('/api/worker/logs', async (req, res) => {
+        try {
+            const { since, level, limit, clear } = req.body || {};
+            res.json(await taskQueue.requestWorker('debug:logs', { since, level, limit, clear }, workerOpts(req)));
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    this.app.get('/api/worker/screenshot', async (req, res) => {
+        try {
+            const format = (req.query?.format === 'jpeg') ? 'jpeg' : 'png';
+            const quality = req.query?.quality ? Number(req.query.quality) : undefined;
+            const data = await taskQueue.requestWorker('debug:screenshot', { format, quality }, workerOpts(req), 15_000);
+            if (!data?.ok) return res.status(500).json({ error: data?.error || 'screenshot_failed' });
+            const buf = Buffer.from(data.dataUrl.split(',')[1], 'base64');
+            res.setHeader('Content-Type', `image/${format}`);
+            res.setHeader('Content-Disposition', `inline; filename="worker-screenshot.${format}"`);
+            res.send(buf);
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+    // ---------------- /Remote Debug API ----------------
+
     this.app.get('/api/extension-path', (req, res) => {
       try {
         const extensionPath = path.join(__dirname, 'views', 'vg-coder');
@@ -427,6 +763,20 @@ class ApiServer {
         res.status(500).json({ success: false, error: error.message });
       }
     });
+
+    // Clipboard API - Write system clipboard from server-side (avoids the
+    // browser's clipboard-write permission prompt on the page).
+    this.app.post('/api/clipboard', async (req, res) => {
+      try {
+        const text = (req.body?.text ?? '').toString();
+        const clipboardy = await import('clipboardy');
+        await clipboardy.default.write(text);
+        res.json({ success: true });
+      } catch (error) {
+        console.error('Clipboard write error:', error);
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
     
     this.app.post('/api/shutdown', async (req, res) => {
         res.json({ success: true });
@@ -447,11 +797,14 @@ class ApiServer {
                 }
             };
             this.httpServer.once('error', onError);
-            this.server = this.httpServer.listen(port, () => {
+            this.server = this.httpServer.listen(port, '127.0.0.1', () => {
                 this.httpServer.removeListener('error', onError);
                 this.port = this.server.address().port;
                 console.log(chalk.green(`🚀 Server Online: http://localhost:${this.port}`));
                 console.log(chalk.blue(`📦 Dist served at: http://localhost:${this.port}/dist`));
+                taskQueue.rehydrateFromProjects(this.projectManager).catch(err => {
+                    console.log(chalk.yellow(`[TaskQueue] Rehydrate failed: ${err.message}`));
+                });
                 resolve();
             });
         };