vg-coder-cli 2.0.68 → 2.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.68",
+  "version": "2.0.70",
   "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/task-queue.js

@@ -125,6 +125,7 @@ class TaskQueue {
         id: w.id,
         email: w.email,
         chromeId: w.chromeId || null,
+        tabId: typeof w.tabId === 'number' ? w.tabId : null,
         status: w.status,
         currentTaskId: w.currentTaskId,
         cooldownUntil: cd,
@@ -180,6 +181,10 @@ class TaskQueue {
       // Phase 1: chromeId comes from worker meta if extension passes it,
       // else reverse-lookup from chromeIdToEmail. Phase 2 will require it.
       existing.chromeId = meta?.chromeId || this._emailToChromeId(email) || existing.chromeId || null;
+      // tabId enables surgical close on recycle (only this tab vs all
+      // AI Studio tabs in the profile). Older extension versions may not
+      // send it — fall back to the previously stored value or null.
+      if (typeof meta?.tabId === 'number') existing.tabId = meta.tabId;
       if (wasUnknown && email !== existing.email) {
         // shouldn't happen — kept for clarity (email already assigned above)
       }
@@ -202,6 +207,9 @@ class TaskQueue {
       // Reverse-lookup from chromeIdToEmail fills the gap for already-bound
       // profiles. Recycle/dispatch paths prefer chromeId when present.
       chromeId: meta?.chromeId || this._emailToChromeId(email) || null,
+      // tabId from extension. When known, recycle closes only this tab —
+      // when null, recycle falls back to close-all-AI-Studio-tabs in profile.
+      tabId: typeof meta?.tabId === 'number' ? meta.tabId : null,
       meta: { ...(meta || {}), registeredAt: Date.now() },
       status: 'idle',
       currentTaskId: null,
@@ -542,13 +550,14 @@ class TaskQueue {
     }
     const workerEmail = worker.email;
     const workerChromeId = worker.chromeId || null;
+    const workerTabId = typeof worker.tabId === 'number' ? worker.tabId : null;
     worker.currentTaskId = null;
     worker.status = 'idle';
     worker.lastSeen = Date.now();
 
     if (task.cancelRequestedAt) {
       // discard result; still recycle the tab so next task gets a clean slate
-      this._recycleWorkerTab(workerEmail, workerChromeId);
+      this._recycleWorkerTab(workerEmail, workerChromeId, workerTabId);
       setImmediate(() => this._drain());
       return;
     }
@@ -569,7 +578,7 @@ class TaskQueue {
     // model URL pinned. AI Studio's "+ New chat" link drops the ?model=
     // query and Angular routerLink ignores href hijack — close+reopen via
     // launcher is the only deterministic way to lock the model per task.
-    this._recycleWorkerTab(workerEmail, workerChromeId);
+    this._recycleWorkerTab(workerEmail, workerChromeId, workerTabId);
     // Drain right away so other idle workers pick up queued tasks while
     // this worker's tab is being recycled (~5s).
     setImmediate(() => this._drain());
@@ -584,30 +593,32 @@ class TaskQueue {
     }
     const workerEmail = worker.email;
     const workerChromeId = worker.chromeId || null;
+    const workerTabId = typeof worker.tabId === 'number' ? worker.tabId : null;
     await this._failOrRequeue(task, worker, error);
     // Only recycle if the worker isn't in cooldown (rate-limited workers
     // have their tab still open intentionally — recycling won't unfreeze
     // the quota and just wastes a tab cycle).
     const w = this.workers.get(socketId);
     if (!w || w.status !== 'rate_limited') {
-      this._recycleWorkerTab(workerEmail, workerChromeId);
+      this._recycleWorkerTab(workerEmail, workerChromeId, workerTabId);
     } else {
       setTimeout(() => this._drain(), INTER_TASK_GAP_MS);
     }
   }
 
   /**
-   * Ask the launcher in the given profile to close all AI Studio tabs and
-   * open a fresh one. The browser-side close fires worker:disconnect →
-   * clearWorker; the open creates a new tab whose worker registers ~3-5s
-   * later. _drain runs naturally on register so any queued task picks up
-   * the fresh worker. Fire-and-forget — errors are logged but don't bubble.
+   * Recycle the worker's tab: close it, then (unless close-only TTL) reopen
+   * a fresh one with the pinned model. Fire-and-forget — errors are logged
+   * but don't bubble.
    *
-   * Prefers chromeId routing when provided (exact profile) — falls back to
-   * workerEmail when chromeId is unknown (e.g. extension hasn't propagated
-   * chromeId yet in Phase 1).
+   * Routing precedence:
+   *   - chromeId pins the exact Chrome profile (falls back to email if absent)
+   *   - tabId pins the exact AI Studio tab in that profile, so user-opened
+   *     tabs in the same profile are NOT closed alongside the worker tab.
+   *     When tabId is null (older extension version), close-all behavior is
+   *     used as before — backward compatible.
    */
-  _recycleWorkerTab(workerEmail, chromeId = null) {
+  _recycleWorkerTab(workerEmail, chromeId = null, tabId = null) {
     if (!workerEmail || workerEmail.startsWith('unknown:')) return;
     // Cancel any pending idle-close — we're about to recycle, no need to close
     // separately. (This handles the race where a task lands during the idle
@@ -615,22 +626,28 @@ class TaskQueue {
     this._cancelIdleClose(workerEmail);
     // Mark workers in this profile as 'recycling' so _drain skips them. Match
     // by chromeId when present (exact profile), else by email (covers the
-    // chromeId-unknown path).
+    // chromeId-unknown path). When tabId is known, only mark the worker for
+    // that specific tab — other workers in the same profile (other tabs)
+    // stay idle and can keep accepting tasks.
     for (const w of this.workers.values()) {
-      const matches = chromeId
-        ? w.chromeId === chromeId
-        : w.email === workerEmail;
+      let matches;
+      if (tabId != null) matches = w.tabId === tabId;
+      else if (chromeId) matches = w.chromeId === chromeId;
+      else matches = w.email === workerEmail;
       if (matches && w.status === 'idle') w.status = 'recycling';
     }
     // Route launcher calls by chromeId when known, email otherwise.
     const routeOpts = chromeId ? { chromeId } : { workerLabel: workerEmail };
     const pinKey = chromeId || workerEmail;
+    // Surgical close: pass tabId so the launcher closes only the worker's
+    // tab. Without tabId, launcher falls back to close-all (legacy behavior).
+    const closePayload = tabId != null ? { tabId } : {};
     // If WORKER_IDLE_TTL_MS === 1, treat post-task recycle as close-only:
     // skip reopen; let _autoLaunchBrowser open a fresh tab when next task lands.
     const closeOnly = WORKER_IDLE_TTL_MS === 1;
     setImmediate(async () => {
       try {
-        await this.requestLauncher('launcher:close_tab', {}, routeOpts, 5_000);
+        await this.requestLauncher('launcher:close_tab', closePayload, routeOpts, 5_000);
         if (closeOnly) {
           console.log(chalk.cyan(`[TaskQueue] Closed tab for ${workerEmail} (VG_WORKER_IDLE_TTL_MS=1)`));
           return;
@@ -694,9 +711,35 @@ class TaskQueue {
       for (const w of this.workers.values()) {
         if (w.email === workerEmail && w.status !== 'idle') return;
       }
-      console.log(chalk.gray(`[TaskQueue] Idle TTL expired for ${workerEmail} — closing tab`));
-      this.requestLauncher('launcher:close_tab', {}, { workerLabel: workerEmail }, 5_000)
-        .catch(err => console.log(chalk.yellow(`[TaskQueue] Idle close ${workerEmail} failed: ${err.message}`)));
+      // Surgical close: collect tabIds of all idle workers in this email
+      // and close them one-by-one so user-opened tabs in the same profile
+      // survive. If a worker has no tabId (older extension), fall back to
+      // close-all-by-email for that worker.
+      const tabIdsByLauncher = new Map();  // routeOpts JSON → [tabId, ...]
+      let needCloseAll = false;
+      for (const w of this.workers.values()) {
+        if (w.email !== workerEmail) continue;
+        if (w.status !== 'idle') continue;
+        const route = w.chromeId ? { chromeId: w.chromeId } : { workerLabel: workerEmail };
+        const key = JSON.stringify(route);
+        if (typeof w.tabId === 'number') {
+          if (!tabIdsByLauncher.has(key)) tabIdsByLauncher.set(key, { route, tabIds: [] });
+          tabIdsByLauncher.get(key).tabIds.push(w.tabId);
+        } else {
+          needCloseAll = true;
+        }
+      }
+      console.log(chalk.gray(`[TaskQueue] Idle TTL expired for ${workerEmail} — closing tab(s)`));
+      if (needCloseAll) {
+        this.requestLauncher('launcher:close_tab', {}, { workerLabel: workerEmail }, 5_000)
+          .catch(err => console.log(chalk.yellow(`[TaskQueue] Idle close ${workerEmail} failed: ${err.message}`)));
+      }
+      for (const { route, tabIds } of tabIdsByLauncher.values()) {
+        for (const tabId of tabIds) {
+          this.requestLauncher('launcher:close_tab', { tabId }, route, 5_000)
+            .catch(err => console.log(chalk.yellow(`[TaskQueue] Idle close tab ${tabId} failed: ${err.message}`)));
+        }
+      }
     }, WORKER_IDLE_TTL_MS);
     if (t.unref) t.unref();
     this._idleCloseTimers.set(workerEmail, t);

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

@@ -369,6 +369,10 @@ function connect() {
         // Register with whatever email we have right now (may be null on cold load).
         const initialEmail = extractEmail();
         const chromeId = (window.vetgo && window.vetgo.chromeId) || null;
+        // tabId injected by background.ts during CONTROLLER script load.
+        // Server uses it for surgical tab close in _recycleWorkerTab so user
+        // tabs in the same profile don't get closed alongside the worker tab.
+        const tabId = (window.vetgo && typeof window.vetgo.tabId === 'number') ? window.vetgo.tabId : null;
         // pinnedModel: lấy từ URL ?model=X — server dùng để re-establish pin
         // sau khi worker register với email thật (không lúc open-tab vì lúc đó
         // launcher có thể chưa scrape email).
@@ -382,9 +386,10 @@ function connect() {
             userAgent: navigator.userAgent,
             email: initialEmail,
             chromeId,
+            tabId,
             pinnedModel
         });
-        console.log(`[TaskWorker] Initial email: ${initialEmail || '(pending)'}, chromeId: ${chromeId || '(none)'}`);
+        console.log(`[TaskWorker] Initial email: ${initialEmail || '(pending)'}, chromeId: ${chromeId || '(none)'}, tabId: ${tabId || '(none)'}`);
 
         if (heartbeatTimer) clearInterval(heartbeatTimer);
         heartbeatTimer = setInterval(() => {
@@ -408,6 +413,7 @@ function connect() {
                         userAgent: navigator.userAgent,
                         email: resolved,
                         chromeId: (window.vetgo && window.vetgo.chromeId) || null,
+                        tabId: (window.vetgo && typeof window.vetgo.tabId === 'number') ? window.vetgo.tabId : null,
                         pinnedModel: pm
                     });
                     console.log(`[TaskWorker] Re-registered with email: ${resolved} (pinnedModel=${pm || 'none'})`);
@@ -490,6 +496,59 @@ 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 via SW message — version, installType, ID,
+    // permissions. Useful when the user has multiple extension installs
+    // (Web Store + Load Unpacked) and we need to know which is live.
+    socket.on('worker:ext-info', async (_payload, ack) => {
+        try {
+            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_EXT_INFO' }, (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({ ok: true, info: reply });
+        } 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));