vg-coder-cli 2.0.67 → 2.0.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.67",
+  "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/api-server.js

@@ -99,7 +99,12 @@ class ApiServer {
 
         // Task worker registration & lifecycle
         socket.on('worker:register', (meta) => { taskQueue.setWorker(socket, meta || {}); });
-        socket.on('worker:heartbeat', () => { /* keep-alive only */ });
+        socket.on('worker:heartbeat', () => {
+            // Bump lastSeen so the stale-worker reaper doesn't drop a live
+            // socket that's just been quiet (no task in flight).
+            const w = taskQueue.workers.get(socket.id);
+            if (w) w.lastSeen = Date.now();
+        });
         socket.on('task:complete', (payload) => {
             if (payload?.taskId) taskQueue.onWorkerComplete(payload.taskId, payload, socket.id);
         });
@@ -799,6 +804,31 @@ class ApiServer {
         } catch (e) { res.status(launcherErr(e)).json({ error: e.message }); }
     });
 
+    // Block until the pinned launcher is ready for tasks. Replaces the common
+    // open-tab → poll-launchers → poll-workers pattern with a single sync
+    // call. Body: { chromeId, timeoutMs?: 15000, requireEmail?: true,
+    // requireWorker?: true }
+    //   - 200 { ok: true, launcher, worker, elapsedMs } when ready
+    //   - 404 launcher_not_found if chromeId never matched a launcher
+    //   - 504 wait_ready_timeout if the readiness condition didn't hold in time
+    this.app.post('/api/launcher/wait-ready', async (req, res) => {
+        try {
+            const body = req.body || {};
+            const chromeId = (body.chromeId || '').toString().trim();
+            if (!chromeId) return res.status(400).json({ error: 'chromeId required' });
+            const result = await taskQueue.waitReady(chromeId, {
+                timeoutMs: body.timeoutMs,
+                requireEmail: body.requireEmail,
+                requireWorker: body.requireWorker,
+            });
+            res.json(result);
+        } catch (e) {
+            if (e.code === 'launcher_not_found') return res.status(404).json({ error: 'launcher_not_found' });
+            if (e.code === 'wait_ready_timeout') return res.status(504).json({ error: 'wait_ready_timeout', details: e.details });
+            res.status(500).json({ error: e.message });
+        }
+    });
+
     // Run a predefined chrome.* command inside the launcher SW. Manifest V3
     // CSP forbids new Function() in service workers, so eval was replaced by
     // a fixed command map. Body:

package/src/server/task-queue.js

@@ -9,6 +9,13 @@ const AUTO_LAUNCH_DEBOUNCE_MS = 30_000;
 const INTER_TASK_GAP_MS = 2_500;
 const RATE_LIMIT_COOLDOWN_MS = 30 * 60_000;
 const COOLDOWN_TICK_MS = 60_000;
+// Reap workers whose socket went silent: no heartbeat AND no task activity
+// past this window. Heartbeat fires every 5s from task-worker.js, so 120s
+// is ~24 missed beats — comfortably past any legitimate network hiccup but
+// short enough that zombie sockets (Chrome tab closed without disconnect
+// event reaching server, content-script paused by power-saver, etc.) don't
+// linger forever and bloat _drain's idleWorkers snapshot.
+const STALE_WORKER_TTL_MS = 120_000;
 const MAX_TASK_ATTEMPTS = 3;
 const RL_CODES = new Set(['rate_limit_exceeded', 'quota_exceeded', 'generation_failed']);
 
@@ -118,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,
@@ -173,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)
       }
@@ -195,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,
@@ -269,6 +284,62 @@ class TaskQueue {
     }
   }
 
+  /**
+   * Poll until a launcher's profile is "ready" for tasks: launcher connected,
+   * email scraped (if requireEmail), and ≥1 idle worker registered for the
+   * chromeId (if requireWorker). Saves callers from running their own
+   * GET /api/launchers + /api/workers poll loop after open-tab.
+   *
+   * Returns a snapshot on success; throws on timeout or immediate-miss.
+   */
+  async waitReady(chromeId, opts = {}) {
+    const timeoutMs = Math.min(Math.max(opts.timeoutMs | 0 || 15_000, 1_000), 60_000);
+    const requireEmail = opts.requireEmail !== false;
+    const requireWorker = opts.requireWorker !== false;
+    const pollMs = 250;
+    const deadline = Date.now() + timeoutMs;
+
+    // Immediate-miss: chromeId never matched a launcher → 404 contract
+    // (vs. timeout). Caller can map differently.
+    const hasLauncher = () => [...this.launchers.values()].some(l => l.chromeId === chromeId);
+    if (!hasLauncher()) {
+      const err = new Error('launcher_not_found');
+      err.code = 'launcher_not_found';
+      throw err;
+    }
+
+    while (Date.now() < deadline) {
+      const launcher = [...this.launchers.values()].find(l => l.chromeId === chromeId);
+      if (launcher) {
+        const emailOk = !requireEmail || (launcher.email && !launcher.email.startsWith('unknown:'));
+        const worker = !requireWorker ? null : [...this.workers.values()].find(w =>
+          w.chromeId === chromeId
+          && w.status === 'idle'
+          && w.email && !w.email.startsWith('unknown:')
+        );
+        const workerOk = !requireWorker || !!worker;
+        if (emailOk && workerOk) {
+          return {
+            ok: true,
+            launcher: { id: launcher.id, chromeId: launcher.chromeId, email: launcher.email },
+            worker: worker ? { id: worker.id, email: worker.email, status: worker.status } : null,
+            elapsedMs: timeoutMs - (deadline - Date.now()),
+          };
+        }
+      } else {
+        // Launcher disconnected during the wait — surface as not_found, not timeout.
+        const err = new Error('launcher_not_found');
+        err.code = 'launcher_not_found';
+        throw err;
+      }
+      await new Promise(r => setTimeout(r, pollMs));
+    }
+    const err = new Error('wait_ready_timeout');
+    err.code = 'wait_ready_timeout';
+    err.details = { chromeId, requireEmail, requireWorker, timeoutMs };
+    throw err;
+  }
+
   // Reverse lookup: find chromeId bound to email. Returns the first match —
   // if two launchers login the same email (test vs prod), this is ambiguous
   // and the caller should prefer explicit chromeId routing instead.
@@ -479,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;
     }
@@ -506,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());
@@ -521,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
@@ -552,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;
@@ -631,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);
@@ -873,9 +979,33 @@ class TaskQueue {
         console.log(chalk.green(`[TaskQueue] Worker ${w.email} cooldown ended`));
       }
     }
+    this._reapStaleWorkers(now);
     if (revived) setImmediate(() => this._drain());
   }
 
+  // Drop workers whose socket has been silent past STALE_WORKER_TTL_MS. Skips
+  // busy/recycling workers — those are mid-task or mid-recycle and may
+  // legitimately not heartbeat until they emit task:complete. Reaping a
+  // zombie worker also triggers _drain because the removal frees a slot
+  // that the legitimate launcher can refill when it reconnects.
+  _reapStaleWorkers(now = Date.now()) {
+    let reaped = 0;
+    for (const w of [...this.workers.values()]) {
+      if (w.status === 'busy' || w.status === 'recycling') continue;
+      const idleFor = now - (w.lastSeen || 0);
+      if (idleFor <= STALE_WORKER_TTL_MS) continue;
+      console.log(chalk.yellow(
+        `[TaskQueue] Reaping stale worker ${w.id} (${w.email || 'unknown'}, idle ${Math.round(idleFor / 1000)}s)`
+      ));
+      // Drop from registry. Don't try to disconnect the socket — if it's
+      // genuinely alive, _drain will skip dispatching to it, and the next
+      // worker:heartbeat or worker:register from that socket re-adds it.
+      this.workers.delete(w.id);
+      reaped++;
+    }
+    if (reaped) setImmediate(() => this._drain());
+  }
+
   _autoLaunchBrowser(task = null) {
     const now = Date.now();
     if (now - this.launchedAt < AUTO_LAUNCH_DEBOUNCE_MS) return;

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'})`);