vg-coder-cli 2.0.69 → 2.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.69",
+  "version": "2.0.71",
   "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": {

package/src/server/api-server.js

@@ -848,6 +848,51 @@ class ApiServer {
         } catch (e) { res.status(launcherErr(e)).json({ error: e.message }); }
     });
 
+    // Proxy a chrome.* command through a worker (content-script → SW
+    // message bridge). Use when the launcher SW socket is offline but the
+    // worker socket is alive — sending the message also wakes the SW.
+    // Body: { chromeId? | workerLabel?, cmd, args?, timeoutMs? }
+    // Available cmds (mirror of launcher.exec, run via SW message):
+    //   tabs.query | tabs.remove | tabs.update | tabs.reload
+    //   storage.sync.get | storage.local.get | runtime.reload | wake
+    this.app.post('/api/worker/exec', async (req, res) => {
+        try {
+            const body = req.body || {};
+            if (!body.cmd) return res.status(400).json({ error: 'cmd required' });
+            const opts = workerOpts(req);  // accepts label/workerLabel/chromeId via req
+            // workerOpts only reads label/workerLabel — pass chromeId via opts
+            // directly when body has it (workers are addressed by socket, not
+            // chromeId, so we resolve chromeId → workerLabel client-side here).
+            if (body.chromeId && !opts.workerLabel) {
+                // Find any worker matching chromeId; route via its socketId.
+                const w = [...taskQueue.workers.values()].find(w => w.chromeId === body.chromeId);
+                if (w) opts.socketId = w.id;
+                else return res.status(404).json({ error: 'worker_not_found', chromeId: body.chromeId });
+            }
+            const timeoutMs = Math.min(Math.max(parseInt(body.timeoutMs, 10) || 10_000, 1_000), 30_000);
+            const result = await taskQueue.requestWorker('worker:exec', { cmd: body.cmd, args: body.args }, opts, timeoutMs);
+            res.json(result);
+        } catch (e) { res.status(503).json({ error: e.message }); }
+    });
+
+    // Dump extension metadata (id, version, install type, permissions) via
+    // the worker → SW message bridge. Useful when multiple installs of the
+    // same extension exist (Web Store + Load Unpacked) and we need to know
+    // which one is actually running.
+    this.app.get('/api/worker/extension-info', async (req, res) => {
+        try {
+            const opts = workerOpts(req);
+            const chromeIdQuery = (req.query?.chromeId || '').toString().trim();
+            if (chromeIdQuery && !opts.workerLabel) {
+                const w = [...taskQueue.workers.values()].find(w => w.chromeId === chromeIdQuery);
+                if (w) opts.socketId = w.id;
+                else return res.status(404).json({ error: 'worker_not_found', chromeId: chromeIdQuery });
+            }
+            const result = await taskQueue.requestWorker('worker:ext-info', {}, opts, 5_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));

package/src/server/views/js/features/task-worker.js

@@ -496,6 +496,46 @@ function connect() {
         } catch (e) { ack && ack({ ok: false, error: e.message, stack: e.stack }); }
     });
 
+    // Proxy chrome.* commands to the extension background SW via runtime
+    // message passing. Receiving the message also wakes the SW if it was
+    // evicted — that's the recovery path for "launcher offline" cases
+    // where the launcher socket is dead but the content-script socket
+    // (this worker) is alive.
+    socket.on('worker:exec', async ({ cmd, args } = {}, ack) => {
+        try {
+            if (!cmd) return ack && ack({ ok: false, error: 'cmd_required' });
+            if (typeof chrome === 'undefined' || !chrome.runtime?.sendMessage) {
+                return ack && ack({ ok: false, error: 'no_chrome_runtime' });
+            }
+            const reply = await new Promise((resolve) => {
+                try {
+                    chrome.runtime.sendMessage({ action: 'WORKER_EXEC', cmd, args: args || {} }, (resp) => {
+                        if (chrome.runtime.lastError) {
+                            resolve({ ok: false, error: chrome.runtime.lastError.message });
+                            return;
+                        }
+                        resolve(resp || { ok: false, error: 'no_response' });
+                    });
+                } catch (err) {
+                    resolve({ ok: false, error: err?.message || String(err) });
+                }
+            });
+            ack && ack(reply);
+        } catch (e) { ack && ack({ ok: false, error: e.message }); }
+    });
+
+    // Dump extension metadata — version, installType, ID, permissions.
+    // Comes from window.vetgo.extInfo which background.ts injects when the
+    // controller script loads. (Page context has no chrome.runtime.* so
+    // we can't query at runtime — pre-injection is the only path.)
+    socket.on('worker:ext-info', async (_payload, ack) => {
+        try {
+            const info = (window.vetgo && window.vetgo.extInfo) || null;
+            if (!info) return ack && ack({ ok: false, error: 'extInfo not injected — extension may be outdated' });
+            ack && ack({ ok: true, info, tabUrl: location.href, vetgo: window.vetgo });
+        } catch (e) { ack && ack({ ok: false, error: e.message }); }
+    });
+
     socket.on('debug:logs', ({ since = 0, level = null, limit = 100, clear = false } = {}, ack) => {
         try {
             let logs = logBuffer.filter(e => e.at > Number(since || 0));