vg-coder-cli 2.0.66 → 2.0.68

package/INTEGRATION.md

@@ -217,6 +217,8 @@ Server có thể chủ động list / đóng / mở tab AI Studio trong từng p
 | `GET` | `/api/launcher/tabs` | `?chromeId=<uuid>` \| `?label=<email>` (optional) | List tabs trong profile (hoặc all profiles nếu bỏ pin) |
 | `POST` | `/api/launcher/close-tab` | `{ chromeId? \| workerLabel?, tabId?, all? }` | Đóng tab cụ thể, hoặc tất cả tab AI Studio nếu bỏ `tabId` |
 | `POST` | `/api/launcher/open-tab` | `{ chromeId? \| workerLabel?, model?, url?, active? }` | Mở tab mới. `model` mặc định `gemini-3-flash-preview`. Response v2.0.52+ kèm `requested_model` / `actual_model` / `fallback_occurred` (URL-based, **không reliable** với AI Studio versions mới — xem note) |
+| `GET` | `/api/launcher/debug` | `?chromeId=<uuid>` \| `?workerLabel=<email>` (optional) | Dump launcher SW state: `swChromeId`, `syncStorage`, `localStorage`, AI Studio tabs, windows count, runtime info. Bỏ pin → broadcast all launchers. (v2.0.65+) |
+| `POST` | `/api/launcher/exec` | `{ chromeId? \| workerLabel? \| all?, cmd, args?, timeoutMs? }` | Chạy 1 lệnh `chrome.*` đã định nghĩa sẵn trong launcher SW. (v2.0.66+, thay cho `eval` bị Manifest V3 CSP chặn) |
 
 **Pin precedence**: `chromeId` > `workerLabel` > default. `chromeId` chỉ exact-match một
 launcher cụ thể — dùng để address **profile chưa bind email** (mới cài extension,
@@ -243,6 +245,98 @@ curl -X POST -d '{"workerLabel":"alice@gmail.com","model":"gemini-3-flash-previe
   -H 'Content-Type: application/json' http://127.0.0.1:6868/api/launcher/open-tab
 ```
 
+### Remote launcher debug (v2.0.65+)
+
+Hai endpoint dùng để inspect / điều khiển launcher SW từ xa thay vì phải mở
+DevTools trong từng Chrome profile:
+
+**`GET /api/launcher/debug`** — dump state cố định:
+
+```bash
+# Một launcher cụ thể
+curl -s "http://127.0.0.1:6868/api/launcher/debug?chromeId=6b420bac-..." | jq
+
+# Broadcast 5 launchers (bỏ pin)
+curl -s http://127.0.0.1:6868/api/launcher/debug | jq
+```
+
+Response per launcher:
+
+```json
+{
+  "ok": true,
+  "data": {
+    "swChromeId": "6b420bac-...",
+    "runtimeId": "comfeilpfnlaoijgndaikpniioglmonf",
+    "extVersion": "1.0.0",
+    "extName": "VetGo Pro",
+    "syncStorage": { "id": "6b420bac-..." },
+    "localStorage": {},
+    "profileInfo": null,
+    "socketId": "KFh5YmiCbYTGBmAzAAAB",
+    "serverUrl": "http://127.0.0.1:6868",
+    "tabs": {
+      "aistudio": [{ "id": 437926431, "url": "...", "status": "complete", "active": true }],
+      "totalCount": 12
+    },
+    "windows": 2,
+    "userAgent": "Mozilla/5.0 ..."
+  }
+}
+```
+
+Dùng để verify chromeId pipeline (launcher SW chromeId == `chrome.storage.sync.id`),
+phát hiện profile có nhiều cửa sổ / quá nhiều tab, debug AI Studio tab missing.
+
+**`POST /api/launcher/exec`** — chạy 1 lệnh đã định nghĩa sẵn trong launcher SW.
+Manifest V3 cấm `new Function()` nên không có eval tự do — đây là tập 10 lệnh
+chrome.* được whitelist, mỗi lệnh có schema args cố định:
+
+| `cmd` | `args` | Trả về |
+|---|---|---|
+| `tabs.query` | `chrome.tabs.QueryInfo` (`{ url?, active?, ... }`) | Mảng tab info `{ id, windowId, url, title, status, active, ... }` |
+| `tabs.get` | `{ tabId: number }` | 1 tab info |
+| `tabs.update` | `{ tabId: number, ...props }` (`url`, `active`, `pinned`, ...) | `{ id, url, active }` |
+| `tabs.reload` | `{ tabId: number, bypassCache?: bool }` | `{ ok: true, tabId }` |
+| `storage.sync.get` | `{ keys?: string \| string[] \| null }` (null = all) | `Record<string, unknown>` |
+| `storage.sync.set` | `{ items: Record<string, unknown> }` | `{ ok: true }` |
+| `storage.local.get` | `{ keys?: ... }` | `Record<string, unknown>` |
+| `runtime.reload` | — | `{ ok: true, scheduled: true }` (extension reload sau ~50ms; ack có thể không tới do SW chết) |
+| `windows.list` | — | Mảng window info `{ id, focused, type, state, incognito }` |
+| `cookies.get` | `{ url: string, name?: string }` | 1 cookie nếu `name`, mảng cookies nếu chỉ `url`. Mỗi cookie: `{ name, value, domain, path, expirationDate, secure, httpOnly }` |
+
+Unknown `cmd` → `{ ok: false, error: "unknown_cmd", available: [...] }` (discovery).
+
+Ví dụ:
+
+```bash
+# Phải có chromeId nào sync với storage UUID không?
+curl -s -X POST -H 'Content-Type: application/json' \
+  -d '{"chromeId":"6b420bac-...","cmd":"storage.sync.get"}' \
+  http://127.0.0.1:6868/api/launcher/exec | jq '.value'
+# → { "id": "6b420bac-..." }
+
+# Profile login Google chưa?
+curl -s -X POST -H 'Content-Type: application/json' \
+  -d '{"chromeId":"6b420bac-...","cmd":"cookies.get","args":{"url":"https://accounts.google.com","name":"SID"}}' \
+  http://127.0.0.1:6868/api/launcher/exec | jq '.value'
+# → { "name": "SID", "value": "...", ... } nếu đã login, null nếu chưa
+
+# Reload extension (debug last resort)
+curl -s -X POST -H 'Content-Type: application/json' \
+  -d '{"chromeId":"6b420bac-...","cmd":"runtime.reload"}' \
+  http://127.0.0.1:6868/api/launcher/exec
+
+# Broadcast: tab AI Studio đang mở ở profile nào?
+curl -s -X POST -H 'Content-Type: application/json' \
+  -d '{"all":true,"cmd":"tabs.query","args":{"url":"*://aistudio.google.com/*"}}' \
+  http://127.0.0.1:6868/api/launcher/exec \
+  | jq '.[] | { chromeId: .launcher.chromeId, tabs: (.value | length) }'
+```
+
+**Thêm command mới** → sửa `execCommands` map trong [vetgo-auto/chrome/src/launcher.ts](vetgo-auto/chrome/src/launcher.ts),
+rebuild + bump version + reload extension trong từng Chrome profile.
+
 `open-tab` response (v2.0.52+):
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.66",
+  "version": "2.0.68",
   "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']);
 
@@ -269,6 +276,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.
@@ -818,13 +881,23 @@ class TaskQueue {
   }
 
   async _dispatch(task, worker) {
+    // Mark worker busy synchronously BEFORE any await so that concurrent
+    // _drain() ticks (each enqueue schedules its own setImmediate(_drain))
+    // don't both observe the same worker as idle and dispatch two tasks to
+    // it. Previously `worker.status = 'busy'` happened after `await
+    // store.saveTask` — the await yielded, a second drain saw worker idle,
+    // and a second task was dispatched onto the same worker. The worker can
+    // only run one task at a time, so the second one would hang in cache
+    // status='running' forever (worker.currentTaskId was overwritten and
+    // onWorkerComplete's `worker.currentTaskId !== taskId` guard rejected
+    // the late completion as stale).
     task.status = 'running';
     task.timing.startedAt = Date.now();
     task.worker = { socketId: worker.id, email: worker.email, ...(worker.meta || {}) };
-    await store.saveTask(task);
     this.cache.set(task.id, task);
     worker.currentTaskId = task.id;
     worker.status = 'busy';
+    await store.saveTask(task);
 
     const port = this.io?.httpServer?.address?.()?.port || 6868;
     const baseUrl = `http://127.0.0.1:${port}`;
@@ -863,9 +936,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;