vg-coder-cli 2.0.49 → 2.0.50

package/INTEGRATION.md

@@ -29,6 +29,7 @@ External Service ◀── POST <webhookUrl>    (push, retry 3×)
 - **Workers**: mỗi tab Chrome trên `aistudio.google.com` với extension VG Coder = 1 worker. Server tự load-balance song song giữa các worker idle.
 - **Launchers**: mỗi Chrome profile = 1 launcher (background service worker của extension). Dùng để mở/đóng tab AI Studio và lock model cho từng task.
 - **Auto-recycle**: sau mỗi task done/failed, server gọi launcher đóng tab worker đó + mở lại tab mới với `?model=<target>` — guarantee model lock per task. Mark worker `recycling` để tránh race.
+- **Idle tab TTL** (v2.0.50+): sau khi recycle xong, nếu không có task mới trong `VG_WORKER_IDLE_TTL_MS` (default `120000` = 2 phút), launcher đóng tab → CPU container về ~0%. Task tiếp theo sẽ trigger `launcher:open_aistudio` để mở lại tab. Set `VG_WORKER_IDLE_TTL_MS=0` để giữ tab always-on (behavior cũ); set `=1` để đóng ngay sau mỗi task.
 - **Failover**: rate-limit / quota error → mark worker `rate_limited` 30 phút, requeue task sang worker khác (max 3 attempts). Tab giữ nguyên qua cooldown (không recycle khi rate-limited).
 - **Default model**: `gemini-3-flash-preview` (free + multimodal — verified working với image + PDF). Avoid `-lite` (text-only) hoặc `-pro-preview` (paid alias to Deep Research).
 - **Persistence**: tasks lưu vào `.vg/tasks/<id>/{task.json,result.md,files/}` của active project.

package/package.json

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

@@ -12,6 +12,18 @@ const COOLDOWN_TICK_MS = 60_000;
 const MAX_TASK_ATTEMPTS = 3;
 const RL_CODES = new Set(['rate_limit_exceeded', 'quota_exceeded', 'generation_failed']);
 
+// Idle worker tab TTL: close the AI Studio tab if no new task arrives within
+// this window after a task completes (and the post-task recycle finishes).
+// Set 0 to disable (worker tab always-on, behavior pre-2.0.50).
+// Set 1 to close immediately after every task. Default 120000 (2 minutes) keeps
+// burst tasks fast while idling background CPU to ~0% on long quiet stretches.
+const WORKER_IDLE_TTL_MS = (() => {
+  const raw = process.env.VG_WORKER_IDLE_TTL_MS;
+  if (raw === undefined || raw === '') return 120_000;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : 120_000;
+})();
+
 class TaskQueue {
   constructor() {
     this.io = null;
@@ -22,6 +34,10 @@ class TaskQueue {
     this.cache = new Map();      // taskId → task
     this.launchedAt = 0;
     this._cooldownTimer = null;
+    // workerEmail → setTimeout handle. When timer fires, close that email's
+    // AI Studio tab (free CPU). Cancelled when a new task arrives or a worker
+    // recycles for that email.
+    this._idleCloseTimers = new Map();
   }
 
   attachIO(io) {
@@ -127,6 +143,27 @@ class TaskQueue {
       ? String(meta.email).toLowerCase()
       : `unknown:${socket.id}`;
 
+    // If the same socket re-registers (e.g. extension scraped the email after
+    // initial register completed), MERGE into the existing entry instead of
+    // replacing it. Replacing would clobber currentTaskId / status while a
+    // task was mid-flight and lose the only path back to onWorkerCompleted.
+    const existing = this.workers.get(socket.id);
+    if (existing) {
+      const wasUnknown = (existing.email || '').startsWith('unknown:');
+      existing.email = email;
+      existing.meta = { ...existing.meta, ...(meta || {}) };
+      existing.lastSeen = Date.now();
+      if (meta?.chromeId && email && !email.startsWith('unknown:')) {
+        this._bindChromeIdToEmail(meta.chromeId, email);
+      }
+      if (wasUnknown && email !== existing.email) {
+        // shouldn't happen — kept for clarity (email already assigned above)
+      }
+      console.log(chalk.green(`[TaskQueue] Worker re-register: ${socket.id} (${email})`));
+      setImmediate(() => this._drain());
+      return true;
+    }
+
     const reg = {
       socket,
       id: socket.id,
@@ -276,6 +313,12 @@ class TaskQueue {
     this.workers.delete(socket.id);
     console.log(chalk.yellow(`[TaskQueue] Worker disconnected: ${socket.id} (${worker.email})`));
 
+    // Drop pending idle-close timer if no other worker for this email remains.
+    if (worker.email && !worker.email.startsWith('unknown:')) {
+      const stillPresent = [...this.workers.values()].some(w => w.email === worker.email);
+      if (!stillPresent) this._cancelIdleClose(worker.email);
+    }
+
     // If a task was running on this worker, fail it (with possible failover).
     if (worker.currentTaskId) {
       const task = this.cache.get(worker.currentTaskId);
@@ -298,6 +341,9 @@ class TaskQueue {
     this.cache.set(task.id, task);
     this.pending.push({ id: task.id, workingDir: task.workingDir });
 
+    // Cancel any pending idle-close so the about-to-dispatch tab stays open.
+    this._cancelAllIdleCloseForLaunch(task);
+
     // Auto-launch if no worker matches the task's pin (or no workers at all).
     if (!this._anyWorkerCouldMatch(task)) this._autoLaunchBrowser(task);
 
@@ -417,6 +463,10 @@ class TaskQueue {
    */
   _recycleWorkerTab(workerEmail) {
     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
+    // window: drain triggers recycle, idle timer becomes redundant.)
+    this._cancelIdleClose(workerEmail);
     // Mark every worker matching this email as 'recycling' so _drain skips
     // them while the close+open is in flight. Without this, a queued task
     // can race in and get dispatched to a worker whose tab is about to
@@ -424,12 +474,22 @@ class TaskQueue {
     for (const w of this.workers.values()) {
       if (w.email === workerEmail && w.status === 'idle') w.status = 'recycling';
     }
+    // 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', {}, { workerLabel: workerEmail }, 5_000);
+        if (closeOnly) {
+          console.log(chalk.cyan(`[TaskQueue] Closed tab for ${workerEmail} (VG_WORKER_IDLE_TTL_MS=1)`));
+          return;
+        }
         await new Promise(r => setTimeout(r, 400));
         await this.requestLauncher('launcher:open_tab', {}, { workerLabel: workerEmail }, 8_000);
         console.log(chalk.cyan(`[TaskQueue] Recycled tab for ${workerEmail}`));
+        // Schedule idle close. If new task arrives before TTL, enqueue() will
+        // cancel this timer.
+        this._scheduleIdleClose(workerEmail);
       } catch (err) {
         console.log(chalk.yellow(`[TaskQueue] Recycle ${workerEmail} failed: ${err.message}`));
         // Restore status if recycle failed and worker still in registry.
@@ -441,6 +501,62 @@ class TaskQueue {
     });
   }
 
+  // ---------- Idle worker tab TTL ----------
+
+  /**
+   * Schedule an automatic tab-close for a worker email after WORKER_IDLE_TTL_MS
+   * of idleness. Only kicks in when there's no pending task that can land on
+   * this worker. Re-arming (e.g. after another recycle) cancels the previous
+   * timer.
+   */
+  _scheduleIdleClose(workerEmail) {
+    if (!workerEmail || workerEmail.startsWith('unknown:')) return;
+    if (!WORKER_IDLE_TTL_MS) return;        // 0 → feature disabled
+    if (WORKER_IDLE_TTL_MS === 1) return;   // 1 → handled inline by _recycleWorkerTab
+    this._cancelIdleClose(workerEmail);
+    const t = setTimeout(() => {
+      this._idleCloseTimers.delete(workerEmail);
+      // Skip if a task is already queued for this worker (or workerless).
+      const hasPendingForEmail = this.pending.some(p => {
+        const task = this.cache.get(p.id);
+        if (!task) return false;
+        if (!task.workerLabel) return true;
+        return task.workerLabel.toLowerCase() === workerEmail;
+      });
+      if (hasPendingForEmail) return;
+      // Skip if any worker for this email is busy/recycling (in-flight work).
+      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}`)));
+    }, WORKER_IDLE_TTL_MS);
+    if (t.unref) t.unref();
+    this._idleCloseTimers.set(workerEmail, t);
+  }
+
+  _cancelIdleClose(workerEmail) {
+    const t = this._idleCloseTimers.get(workerEmail);
+    if (t) {
+      clearTimeout(t);
+      this._idleCloseTimers.delete(workerEmail);
+    }
+  }
+
+  _cancelAllIdleCloseForLaunch(task) {
+    // When a task is enqueued, cancel any idle-close timers that could
+    // otherwise close a tab we're about to dispatch to.
+    if (!task) return;
+    if (task.workerLabel) {
+      this._cancelIdleClose(task.workerLabel.toLowerCase());
+    } else {
+      for (const email of Array.from(this._idleCloseTimers.keys())) {
+        this._cancelIdleClose(email);
+      }
+    }
+  }
+
   // ---------- Internal ----------
 
   _workerByCurrentTask(taskId) {
@@ -531,10 +647,15 @@ class TaskQueue {
       return;
     }
 
-    // Snapshot workers with status idle
-    let idleWorkers = [...this.workers.values()].filter(w => w.status === 'idle');
+    // Snapshot workers with status idle. Skip workers whose email scrape
+    // is still pending (`unknown:<sid>`) — extension typically re-registers
+    // ~3-5s later with the real email, and dispatching during that window
+    // races with the re-register and clobbers task lifecycle state.
+    let idleWorkers = [...this.workers.values()].filter(w =>
+      w.status === 'idle' && !(w.email || '').startsWith('unknown:')
+    );
     if (!idleWorkers.length && this.pending.length) {
-      // No idle workers — nothing to dispatch right now.
+      // No usable idle workers — nothing to dispatch right now.
       return;
     }