vg-coder-cli 2.0.67 → 2.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.67",
+  "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.
@@ -873,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;