vg-coder-cli 2.0.68 → 2.0.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.68",
+  "version": "2.0.69",
   "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/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'})`);