@linkegringo/mcp 1.0.5 → 1.0.7

package/dist/index.js

@@ -9,229 +9,234 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 // src/tools/audit-profile.ts
 import { z } from "zod";
 
-// src/cdp/probe.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-function isLinkeGringoUrl(url = "") {
-  const lower = url.toLowerCase();
-  return lower.includes("localhost:5173") || lower.includes("127.0.0.1:5173") || lower.includes("localhost:4173") || lower.includes("127.0.0.1:4173") || lower.includes("linkegringo") || lower.includes("muriel-gasparini.github.io");
-}
-function findDevToolsActivePort() {
-  const possiblePaths = [
-    // Linux
-    path.join(os.homedir(), ".config", "google-chrome", "DevToolsActivePort"),
-    path.join(os.homedir(), ".config", "chromium", "DevToolsActivePort"),
-    path.join(os.homedir(), ".config", "google-chrome-beta", "DevToolsActivePort"),
-    // macOS
-    path.join(os.homedir(), "Library", "Application Support", "Google", "Chrome", "DevToolsActivePort"),
-    // Windows
-    path.join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "User Data", "DevToolsActivePort")
-  ];
-  for (const p of possiblePaths) {
-    if (p && fs.existsSync(p)) {
-      try {
-        const lines = fs.readFileSync(p, "utf8").trim().split("\n");
-        if (lines.length >= 2) {
-          const port = parseInt(lines[0].trim(), 10);
-          const wsPath = lines[1].trim();
-          if (port > 0 && wsPath) {
-            return { port, wsPath };
-          }
-        }
-      } catch {
+// src/bridge/state.ts
+import { EventEmitter } from "events";
+var BridgeJobStore = class extends EventEmitter {
+  jobs = /* @__PURE__ */ new Map();
+  pendingQueue = [];
+  createJob(type, payload) {
+    const id = `job_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const now = Date.now();
+    const job = {
+      id,
+      type,
+      payload,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.jobs.set(id, job);
+    this.pendingQueue.push(id);
+    this.emit("job:created", job);
+    this.emit(`job:${id}`, job);
+    return job;
+  }
+  getJob(id) {
+    return this.jobs.get(id);
+  }
+  getPendingJob(id) {
+    if (id) {
+      const job = this.jobs.get(id);
+      return job && (job.status === "pending" || job.status === "processing") ? job : void 0;
+    }
+    while (this.pendingQueue.length > 0) {
+      const nextId = this.pendingQueue[0];
+      const job = this.jobs.get(nextId);
+      if (job && job.status === "pending") {
+        return job;
       }
+      this.pendingQueue.shift();
     }
+    return void 0;
   }
-  return null;
-}
-async function probeViaWebSocket(port, wsPath, timeoutMs = 2e3) {
-  const wsUrl = `ws://127.0.0.1:${port}${wsPath}`;
-  if (typeof globalThis.WebSocket !== "function") return null;
-  return new Promise((resolve) => {
-    let ws;
-    const timer = setTimeout(() => {
-      try {
-        ws?.close();
-      } catch {
+  markProcessing(id) {
+    const job = this.jobs.get(id);
+    if (!job) return void 0;
+    job.status = "processing";
+    job.updatedAt = Date.now();
+    this.emit(`job:${id}`, job);
+    return job;
+  }
+  completeJob(id, result) {
+    const job = this.jobs.get(id);
+    if (!job) {
+      throw new Error(`Job n\xE3o encontrado: ${id}`);
+    }
+    job.status = "completed";
+    job.result = result;
+    job.updatedAt = Date.now();
+    const idx = this.pendingQueue.indexOf(id);
+    if (idx !== -1) {
+      this.pendingQueue.splice(idx, 1);
+    }
+    this.emit(`job:${id}`, job);
+    this.emit("job:completed", job);
+    return job;
+  }
+  failJob(id, error) {
+    const job = this.jobs.get(id);
+    if (!job) {
+      throw new Error(`Job n\xE3o encontrado: ${id}`);
+    }
+    job.status = "failed";
+    job.error = error;
+    job.updatedAt = Date.now();
+    const idx = this.pendingQueue.indexOf(id);
+    if (idx !== -1) {
+      this.pendingQueue.splice(idx, 1);
+    }
+    this.emit(`job:${id}`, job);
+    this.emit("job:failed", job);
+    return job;
+  }
+  async waitForJob(id, timeoutMs = 6e4) {
+    const existing = this.jobs.get(id);
+    if (existing && (existing.status === "completed" || existing.status === "failed")) {
+      return existing;
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.off(`job:${id}`, onUpdate);
+        const current = this.jobs.get(id);
+        if (current) resolve(current);
+        else reject(new Error(`Timeout aguardando pelo job ${id}`));
+      }, timeoutMs);
+      const onUpdate = (job) => {
+        if (job.status === "completed" || job.status === "failed") {
+          clearTimeout(timer);
+          this.off(`job:${id}`, onUpdate);
+          resolve(job);
+        }
+      };
+      this.on(`job:${id}`, onUpdate);
+    });
+  }
+  getAllJobs() {
+    return Array.from(this.jobs.values());
+  }
+  getPendingCount() {
+    return this.jobs.size > 0 ? Array.from(this.jobs.values()).filter((j) => j.status === "pending" || j.status === "processing").length : 0;
+  }
+  // Watcher tracking
+  activeWatchers = /* @__PURE__ */ new Set();
+  registerWatcher(id) {
+    this.activeWatchers.add(id);
+    this.emit("watcher:connected", id);
+  }
+  unregisterWatcher(id) {
+    this.activeWatchers.delete(id);
+    this.emit("watcher:disconnected", id);
+  }
+  getWatcherCount() {
+    return this.activeWatchers.size;
+  }
+  hasActiveWatcher() {
+    return this.activeWatchers.size > 0;
+  }
+  cancelAllPending(reason = "Cancelado pelo usu\xE1rio via interface web") {
+    let count = 0;
+    while (this.pendingQueue.length > 0) {
+      const id = this.pendingQueue.shift();
+      const job = this.jobs.get(id);
+      if (job && (job.status === "pending" || job.status === "processing")) {
+        job.status = "failed";
+        job.error = reason;
+        job.updatedAt = Date.now();
+        count++;
+        this.emit(`job:${id}`, job);
+        this.emit("job:failed", job);
       }
-      resolve(null);
-    }, timeoutMs);
+    }
+    this.emit("queue:cleared", count);
+    return count;
+  }
+  clear() {
+    this.jobs.clear();
+    this.pendingQueue = [];
+    this.activeWatchers.clear();
+    this.removeAllListeners();
+  }
+};
+var bridgeJobStore = new BridgeJobStore();
+
+// src/bridge/client.ts
+var DEFAULT_BRIDGE_URL = process.env.LINKEGRINGO_BRIDGE_URL || (process.env.NODE_ENV === "test" ? "" : "http://127.0.0.1:5174");
+async function getRemoteOrLocalPendingJob(jobId, bridgeUrl = DEFAULT_BRIDGE_URL) {
+  if (bridgeUrl) {
     try {
-      ws = new globalThis.WebSocket(wsUrl);
-    } catch {
+      const url = jobId ? `${bridgeUrl}/api/jobs/pending?id=${encodeURIComponent(jobId)}` : `${bridgeUrl}/api/jobs/pending`;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 2e3);
+      const res = await fetch(url, { signal: controller.signal });
       clearTimeout(timer);
-      resolve(null);
-      return;
+      if (res.ok) {
+        const data = await res.json();
+        if (data.ok && data.job) {
+          return data.job;
+        }
+      }
+    } catch {
     }
-    let linkeTarget = null;
-    let linkeGringoTabs = [];
-    let otherTabsCount = 0;
-    ws.onopen = () => {
-      ws.send(JSON.stringify({ id: 1, method: "Target.getTargets" }));
-    };
-    ws.onmessage = (event) => {
-      try {
-        const msg = JSON.parse(String(event.data));
-        if (msg.id === 1) {
-          const targets = msg.result?.targetInfos || [];
-          const pageTargets = targets.filter((t) => t.type === "page");
-          const matched = pageTargets.filter((t) => isLinkeGringoUrl(t.url));
-          linkeGringoTabs = matched.map((t) => ({
-            id: t.targetId,
-            title: t.title,
-            url: t.url
-          }));
-          otherTabsCount = pageTargets.length - matched.length;
-          if (linkeGringoTabs.length === 0) {
-            clearTimeout(timer);
-            ws.close();
-            resolve({ linkeGringoTabs: [], otherTabsCount, sessionState: null });
-            return;
-          }
-          linkeTarget = matched[0];
-          ws.send(
-            JSON.stringify({
-              id: 2,
-              method: "Target.attachToTarget",
-              params: { targetId: linkeTarget.targetId, flatten: true }
-            })
-          );
-        } else if (msg.id === 2) {
-          const sessionId = msg.result?.sessionId;
-          ws.send(
-            JSON.stringify({
-              id: 3,
-              sessionId,
-              method: "Runtime.evaluate",
-              params: {
-                expression: 'window.localStorage.getItem("linkegringo_active_session")',
-                returnByValue: true
-              }
-            })
-          );
-        } else if (msg.id === 3) {
-          clearTimeout(timer);
-          ws.close();
-          const raw = msg.result?.result?.value;
-          let session = null;
+  }
+  return bridgeJobStore.getPendingJob(jobId);
+}
+async function completeRemoteOrLocalJob(jobId, result, bridgeUrl = DEFAULT_BRIDGE_URL) {
+  if (bridgeUrl) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3);
+      const res = await fetch(`${bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}/complete`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ result }),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (res.ok) {
+        const data = await res.json();
+        if (data.ok && data.job) {
           try {
-            if (raw) session = JSON.parse(raw);
+            if (bridgeJobStore.getJob(jobId)) {
+              bridgeJobStore.completeJob(jobId, result);
+            }
           } catch {
           }
-          const hasUploadedProfile = Boolean(session && session.profile);
-          const sessionState = {
-            hasUploadedProfile,
-            candidateName: session?.profile?.name,
-            targetRole: session?.profile?.targetRole || session?.objective,
-            step: session?.step || (hasUploadedProfile ? "diagnostic" : "upload"),
-            inboundScore: session?.review?.inboundReadinessScore,
-            profile: session?.profile || null,
-            review: session?.review || null
-          };
-          resolve({
-            linkeGringoTabs,
-            otherTabsCount,
-            sessionState
-          });
+          return data.job;
         }
-      } catch {
-        clearTimeout(timer);
-        try {
-          ws?.close();
-        } catch {
-        }
-        resolve(null);
       }
-    };
-    ws.onerror = () => {
-      clearTimeout(timer);
-      resolve(null);
-    };
-  });
-}
-async function checkChromeCdp(port = 9222, host = "127.0.0.1", timeoutMs = 5e3) {
-  const activePortData = findDevToolsActivePort();
-  if (activePortData) {
-    const wsResult = await probeViaWebSocket(activePortData.port, activePortData.wsPath, timeoutMs);
-    if (wsResult) {
-      const found = wsResult.linkeGringoTabs.length > 0;
-      return {
-        isRunning: true,
-        port: activePortData.port,
-        host: "127.0.0.1",
-        browser: "Google Chrome (DevTools Protocol)",
-        protocolVersion: "1.3",
-        activeTabs: wsResult.linkeGringoTabs,
-        linkeGringoTabs: wsResult.linkeGringoTabs,
-        otherTabsCount: wsResult.otherTabsCount,
-        linkeGringoTabFound: found,
-        linkeGringoTabUrl: wsResult.linkeGringoTabs[0]?.url,
-        sessionState: wsResult.sessionState
-      };
+    } catch {
     }
   }
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const versionRes = await fetch(`http://${host}:${port}/json/version`, {
-      signal: controller.signal
-    });
-    if (!versionRes.ok) {
-      throw new Error(`HTTP ${versionRes.status}: ${versionRes.statusText}`);
-    }
-    const versionData = await versionRes.json();
-    let pageTabs = [];
+  return bridgeJobStore.completeJob(jobId, result);
+}
+async function failRemoteOrLocalJob(jobId, error, bridgeUrl = DEFAULT_BRIDGE_URL) {
+  if (bridgeUrl) {
     try {
-      const listRes = await fetch(`http://${host}:${port}/json/list`, {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3);
+      const res = await fetch(`${bridgeUrl}/api/jobs/${encodeURIComponent(jobId)}/fail`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error }),
         signal: controller.signal
       });
-      if (listRes.ok) {
-        const rawTabs = await listRes.json();
-        if (Array.isArray(rawTabs)) {
-          pageTabs = rawTabs.filter((t) => t.type === "page");
+      clearTimeout(timer);
+      if (res.ok) {
+        const data = await res.json();
+        if (data.ok && data.job) {
+          try {
+            if (bridgeJobStore.getJob(jobId)) {
+              bridgeJobStore.failJob(jobId, error);
+            }
+          } catch {
+          }
+          return data.job;
         }
       }
     } catch {
     }
-    const linkeGringoTabs = pageTabs.filter((t) => isLinkeGringoUrl(t.url)).map((t) => ({
-      id: t.id,
-      title: t.title,
-      url: t.url,
-      webSocketDebuggerUrl: t.webSocketDebuggerUrl
-    }));
-    const otherTabsCount = pageTabs.length - linkeGringoTabs.length;
-    const found = linkeGringoTabs.length > 0;
-    return {
-      isRunning: true,
-      port,
-      host,
-      browser: versionData.Browser,
-      protocolVersion: versionData["Protocol-Version"],
-      activeTabs: linkeGringoTabs,
-      linkeGringoTabs,
-      otherTabsCount,
-      linkeGringoTabFound: found,
-      linkeGringoTabUrl: linkeGringoTabs[0]?.url,
-      sessionState: null
-    };
-  } catch (err) {
-    const error = err;
-    const isTimeout = error.name === "AbortError" || error.name === "TimeoutError";
-    return {
-      isRunning: false,
-      port,
-      host,
-      activeTabs: [],
-      linkeGringoTabs: [],
-      otherTabsCount: 0,
-      linkeGringoTabFound: false,
-      sessionState: null,
-      error: isTimeout ? "Conex\xE3o expirou (Chrome n\xE3o respondeu em 2s na porta " + port + ")" : "Porta fechada ou depura\xE7\xE3o remota desativada. Acesse chrome://inspect/#remote-debugging para ativar."
-    };
-  } finally {
-    clearTimeout(timeoutId);
   }
+  return bridgeJobStore.failJob(jobId, error);
 }
 
 // src/tools/audit-profile.ts
@@ -286,74 +291,59 @@ async function handleAuditProfile(input) {
   let skills = input.skills || [];
   const rawExperiences = [...input.experiences || []];
   if (!headline && !input.profileText && rawExperiences.length === 0) {
-    try {
-      const cdp = await checkChromeCdp();
-      if (cdp.sessionState?.hasUploadedProfile && cdp.sessionState.profile) {
-        const p = cdp.sessionState.profile;
-        headline = p.headline || "";
-        summary = p.summary || "";
-        skills = p.skills || [];
-        if (Array.isArray(p.experiences)) {
-          for (const exp of p.experiences) {
-            rawExperiences.push({
-              company: exp.companyName || exp.company || "Company",
-              title: exp.title || "Engineer",
-              bullets: exp.bullets,
-              description: exp.description
-            });
-          }
-        }
-      } else if (cdp.linkeGringoTabFound) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `
-# \u26A0\uFE0F Nenhum Perfil Carregado no LinkeGringo
+    const pendingJob = await getRemoteOrLocalPendingJob();
+    if (pendingJob) {
+      const p = pendingJob.payload || {};
+      return {
+        content: [
+          {
+            type: "text",
+            text: `
+# \u{1F4C4} Job Pendente da Interface Web Detectado!
 
-A aplica\xE7\xE3o **LinkeGringo est\xE1 aberta no seu navegador** (\`${cdp.linkeGringoTabUrl || "http://localhost:5173"}\`), mas o **upload do PDF do LinkedIn ainda n\xE3o foi realizado**.
+O front-end em \`localhost:5173\` submeteu o seguinte job para o Agente de IA:
+- **Job ID**: \`${pendingJob.id}\`
+- **Tipo**: \`${pendingJob.type}\`
+- **Cargo Almejado**: ${p.targetRole || input.targetRole || "Senior Software Engineer"}
+- **Possui PDF Base64**: ${Boolean(p.pdfBase64)}
 
 ---
-
-### \u{1F4A1} Pr\xF3ximo Passo
-Por favor, acesse a aba do LinkeGringo no seu navegador e **arraste o PDF do seu perfil do LinkedIn para o dropzone** (ou clique para selecionar o arquivo).
-
-Assim que o upload for processado pela aplica\xE7\xE3o web, chame o \`audit_profile\` novamente para auditar o perfil real automaticamente!
+\u{1F4A1} **A\xE7\xE3o para o Agente de IA**:
+Processe a auditoria deste perfil e chame a ferramenta \`submit_job_result\` passando \`jobId: "${pendingJob.id}"\` e o resultado formatado (\`{ profile, review }\`).
+A tela do usu\xE1rio avan\xE7ar\xE1 instantaneamente para o Diagn\xF3stico!
 `.trim()
-            }
-          ],
-          structuredData: {
-            status: "waiting_for_upload",
-            linkeGringoTabUrl: cdp.linkeGringoTabUrl,
-            message: "O usu\xE1rio ainda n\xE3o subiu o PDF do LinkedIn na aplica\xE7\xE3o web.",
-            actionRequired: "upload_pdf"
           }
-        };
-      } else {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `
+        ],
+        structuredData: {
+          status: "pending_bridge_job",
+          jobId: pendingJob.id,
+          jobType: pendingJob.type,
+          payload: pendingJob.payload,
+          actionRequired: "submit_job_result"
+        }
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
 # \u26A0\uFE0F Nenhum Perfil Fornecido para Auditoria
 
-Nenhum dado de perfil foi informado e a aplica\xE7\xE3o LinkeGringo n\xE3o foi detectada no navegador.
+Nenhum dado de perfil foi informado e n\xE3o h\xE1 nenhum job pendente na interface web (porta 5174).
 
 ### Como prosseguir:
-1. **Pela Web**: Abra o LinkeGringo em \`http://localhost:5173\` no Google Chrome e fa\xE7a o upload do PDF do seu LinkedIn; OU
-2. **Via Par\xE2metros**: Forne\xE7a o texto bruto do perfil no par\xE2metro \`profileText\` ou informe \`headline\`, \`experiences\` e \`skills\`.
+1. **Pela Interface Web**: Abra o LinkeGringo (http://localhost:5173), selecione o cargo-alvo e envie o PDF do LinkedIn no Modo Agente MCP; OU
+2. **Via Par\xE2metros MCP**: Forne\xE7a o texto bruto do perfil no par\xE2metro \`profileText\` ou informe \`headline\`, \`experiences\` e \`skills\` diretamente nesta ferramenta.
 `.trim()
-            }
-          ],
-          structuredData: {
-            status: "missing_profile",
-            message: "Nenhum perfil fornecido e aplica\xE7\xE3o LinkeGringo n\xE3o detectada no navegador.",
-            actionRequired: "provide_input_or_open_web"
-          }
-        };
+        }
+      ],
+      structuredData: {
+        status: "missing_profile",
+        message: "Nenhum perfil fornecido e nenhum job pendente no Bridge HTTP.",
+        actionRequired: "provide_input_or_open_web"
       }
-    } catch {
-    }
+    };
   }
   if (input.profileText && !headline && rawExperiences.length === 0) {
     const lines = input.profileText.split("\n").map((l) => l.trim()).filter(Boolean);
@@ -1026,8 +1016,8 @@ var simulateRecruiterSearchInputSchema = z8.object({
 });
 async function handleSimulateRecruiterSearch(input) {
   const defaultKeywords = input.requiredKeywords?.length ? input.requiredKeywords : [input.targetRole, "Senior", "Remote", "Architecture", "Scale"];
-  const highPriorityText = `${input.headline} ${input.skills.join(" ")}`;
-  const bodyText = `${input.summary} ${input.experienceBullets.join(" ")}`;
+  const highPriorityText = `${input.headline || ""} ${(input.skills || []).join(" ")}`;
+  const bodyText = `${input.summary || ""} ${(input.experienceBullets || []).join(" ")}`;
   const evaluations = defaultKeywords.map((term) => {
     const inHighPriority = termMatchesText(highPriorityText, term);
     const inBody = termMatchesText(bodyText, term);
@@ -1200,12 +1190,13 @@ var generateHeadlineInputSchema = z10.object({
   seniorityOrScope: z10.string().default("US Remote").describe("Senioridade ou disponibilidade (ex: US Remote, Global Teams, Staff)")
 });
 async function handleGenerateHeadline(input) {
-  const techsStr = input.coreTechnologies.slice(0, 4).join(" \u2022 ");
+  const coreTechs = Array.isArray(input.coreTechnologies) ? input.coreTechnologies : ["TypeScript", "React", "Node.js"];
+  const techsStr = coreTechs.slice(0, 4).join(" \u2022 ");
   const diffStr = input.keyDifferentiator || "Distributed Systems";
   const scopeStr = input.seniorityOrScope || "US Remote";
   const option1 = `${input.targetRole} | ${techsStr} | ${diffStr} | ${scopeStr}`;
   const option2 = `${input.targetRole} | Scaling ${diffStr} with ${techsStr} | ${scopeStr}`;
-  const option3 = `${input.targetRole} | ${input.coreTechnologies.slice(0, 3).join(", ")} Specialist | ${scopeStr}`;
+  const option3 = `${input.targetRole} | ${coreTechs.slice(0, 3).join(", ")} Specialist | ${scopeStr}`;
   const proposals = [
     {
       type: "Niche Specialist (Recomendada)",
@@ -1255,79 +1246,148 @@ ${proposals.map(
   };
 }
 
-// src/tools/cdp-check.ts
+// src/tools/get-pending-job.ts
 import { z as z11 } from "zod";
-var checkChromeCdpInputSchema = z11.object({
-  port: z11.number().default(9222).describe("Porta do Chrome DevTools Protocol a ser testada (padr\xE3o 9222)"),
-  host: z11.string().default("127.0.0.1").describe("Host do Chrome (padr\xE3o 127.0.0.1)"),
-  timeoutMs: z11.number().default(5e3).describe("Tempo limite em milissegundos para a conex\xE3o")
+var getPendingJobInputSchema = z11.object({
+  jobId: z11.string().optional().describe("ID espec\xEDfico do job a ser buscado (opcional. Se omitido, pega o pr\xF3ximo da fila)")
 });
-async function handleCheckChromeCdp(input) {
-  const status = await checkChromeCdp(input.port, input.host, input.timeoutMs);
-  const session = status.sessionState;
-  const isProfileLoaded = Boolean(session?.hasUploadedProfile);
-  let sessionSection = "";
-  if (status.linkeGringoTabFound) {
-    if (isProfileLoaded) {
-      sessionSection = `
-### \u{1F464} Sess\xE3o do LinkeGringo: \u{1F7E2} Perfil Carregado
-- **Candidato**: ${session?.candidateName || "Identificado"}
-- **Cargo Alvo**: ${session?.targetRole || "N\xE3o especificado"}
-- **Passo Atual**: \`${session?.step || "diagnostic"}\`
-- **Inbound Score**: ${session?.inboundScore !== void 0 ? `${session.inboundScore}/100` : "Pronto para c\xE1lculo"}
-
-> \u{1F4A1} **Instru\xE7\xE3o para a IA**: O perfil do usu\xE1rio j\xE1 est\xE1 carregado. Voc\xEA pode utilizar diretamente as ferramentas \`audit_profile\`, \`simulate_recruiter_search\`, \`generate_headline_proposals\` e \`convert_to_xyz_bullet\` com os dados do candidato.
-`;
-    } else {
-      sessionSection = `
-### \u{1F464} Sess\xE3o do LinkeGringo: \u{1F7E1} Aguardando Upload do PDF
-- **Passo Atual**: \`upload\` (Tela inicial)
-- **Status do Arquivo**: Nenhum PDF do LinkedIn foi carregado ainda pelo usu\xE1rio.
-
-> \u{1F4A1} **Instru\xE7\xE3o para a IA**: O usu\xE1rio est\xE1 com o LinkeGringo aberto, mas ainda n\xE3o subiu o PDF. **Pe\xE7a educadamente para o usu\xE1rio arrastar ou selecionar o PDF do seu perfil do LinkedIn no dropzone da aplica\xE7\xE3o web** (${status.linkeGringoTabUrl || "http://localhost:5173"}). Assim que o usu\xE1rio subir o PDF, voc\xEA ter\xE1 acesso instant\xE2neo aos dados para auditar e otimizar!
-`;
-    }
-  } else {
-    sessionSection = `
-### \u{1F310} Sess\xE3o do LinkeGringo: \u26A0\uFE0F N\xE3o Detectada
-> O LinkeGringo n\xE3o foi detectado em nenhuma aba aberta. Pe\xE7a ao usu\xE1rio para abrir \`http://localhost:5173\` no navegador ou fornecer o texto do perfil diretamente.
-`;
+async function handleGetPendingJob(input = {}) {
+  const job = await getRemoteOrLocalPendingJob(input.jobId);
+  if (!job) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Nenhum job pendente no momento na interface web do LinkeGringo."
+        }
+      ],
+      structuredData: {
+        jobFound: false,
+        pendingCount: bridgeJobStore.getPendingCount()
+      }
+    };
   }
-  const markdownSummary = `
-# Status do Chrome Remote Debugging (CDP) & LinkeGringo
-
-**Porta CDP**: ${status.host}:${status.port}
-**Status do Chrome**: ${status.isRunning ? "\u{1F7E2} Conectado e Ativo" : "\u{1F534} Desconectado"}
-
-${status.isRunning ? `
-- **Vers\xE3o do Navegador**: ${status.browser || "Google Chrome"}
-- **Aba do LinkeGringo**: ${status.linkeGringoTabFound ? `\u2713 Detectada (\`${status.linkeGringoTabUrl}\`)` : "\u26A0\uFE0F Nenhuma aba do LinkeGringo aberta"}
-
-### \u{1F6E1}\uFE0F Privacy Shield Ativo
-- **Abas Pessoais Protegidas**: ${status.otherTabsCount} aba(s) abertas no navegador foram preservadas sem inspe\xE7\xE3o (e-mails, mensageiros, documentos).
-- **Escopo Restrito**: O LinkeGringo acessa exclusivamente abas pertencentes \xE0 pr\xF3pria aplica\xE7\xE3o LinkeGringo.
-
-${sessionSection}
-` : `
-> \u274C **Motivo**: ${status.error || "Porta fechada."}
-> 
-> **Como ativar no Google Chrome (M144+)**:
-> 1. Abra uma nova aba e acesse: \`chrome://inspect/#remote-debugging\`
-> 2. Marque a op\xE7\xE3o para **Ativar depura\xE7\xE3o remota**.
-> 3. Se estiver usando o servidor oficial DevTools MCP, configure com \`--autoConnect\`.
-`}
+  bridgeJobStore.markProcessing(job.id);
+  let details = "";
+  if (job.type === "parse_and_diagnose") {
+    const p = job.payload || {};
+    details = `
+- **Tipo de A\xE7\xE3o**: Extra\xE7\xE3o Multimodal e Diagn\xF3stico de Perfil (parseAndDiagnose)
+- **Cargo Almejado**: ${p.targetRole || "N\xE3o especificado"}
+- **Possui PDF Base64**: ${Boolean(p.pdfBase64)} (${p.pdfBase64 ? Math.round(p.pdfBase64.length / 1024) + " KB base64" : "N/A"})
+- **Possui Texto**: ${Boolean(p.pdfText)}
+`.trim();
+  } else if (job.type === "generate_interview") {
+    details = `
+- **Tipo de A\xE7\xE3o**: Gera\xE7\xE3o de Perguntas de Entrevista T\xE9cnica
+- **Candidato**: ${job.payload?.profile?.name || "N\xE3o informado"}
+- **Cargo Almejado**: ${job.payload?.objective?.primaryRole || "N\xE3o informado"}
+`.trim();
+  } else if (job.type === "generate_rewritten_profile") {
+    details = `
+- **Tipo de A\xE7\xE3o**: Reescrita do Perfil com Bullets Google XYZ
+- **Candidato**: ${job.payload?.profile?.name || "N\xE3o informado"}
+- **Fatos Confirmados**: ${job.payload?.confirmedFacts?.length || 0} fatos
 `.trim();
+  }
   return {
     content: [
       {
         type: "text",
-        text: markdownSummary
+        text: `
+# \u{1F4E5} Job da Interface Web Encontrado!
+
+- **Job ID**: \`${job.id}\`
+- **Tipo**: \`${job.type}\`
+- **Criado em**: ${new Date(job.createdAt).toLocaleTimeString()}
+
+${details}
+
+---
+\u{1F4A1} **Instru\xE7\xF5es para o Agente de IA**:
+1. Processe a intelig\xEAncia requerida para este job com base nas diretrizes do LinkeGringo.
+2. Ao concluir, chame a ferramenta \`submit_job_result\` passando \`jobId: "${job.id}"\` e o JSON estruturado no campo \`result\`.
+3. A interface web em \`localhost:5173\` atualizar\xE1 a tela no mesmo instante!
+`.trim()
       }
     ],
-    structuredData: status
+    structuredData: {
+      jobFound: true,
+      job: {
+        id: job.id,
+        type: job.type,
+        payload: job.payload,
+        createdAt: job.createdAt
+      }
+    }
   };
 }
 
+// src/tools/submit-job-result.ts
+import { z as z12 } from "zod";
+var submitJobResultInputSchema = z12.object({
+  jobId: z12.string().describe("ID do job a ser conclu\xEDdo"),
+  result: z12.any().describe("JSON com os dados estruturados exigidos pelo front-end (ex: ParseAndDiagnoseResult, InterviewPlan, ProfileAnalysis)"),
+  status: z12.enum(["completed", "failed"]).default("completed").describe("Status final do job"),
+  error: z12.string().optional().describe('Mensagem de erro caso o status seja "failed"')
+});
+async function handleSubmitJobResult(input) {
+  try {
+    if (input.status === "failed") {
+      const job2 = await failRemoteOrLocalJob(input.jobId, input.error || "Falha no processamento pelo agente");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u26A0\uFE0F Job ${job2.id} marcado como com falha. A interface web exibir\xE1 a mensagem de erro.`
+          }
+        ],
+        structuredData: {
+          success: false,
+          jobId: job2.id,
+          status: "failed"
+        }
+      };
+    }
+    const job = await completeRemoteOrLocalJob(input.jobId, input.result);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+\u2705 **Resultado Enviado com Sucesso para a Interface Web!**
+
+- **Job ID**: \`${job.id}\`
+- **Tipo**: \`${job.type}\`
+- **Status**: \`completed\`
+
+O front-end em \`localhost:5173\` acabou de receber a resposta formatada e atualizou a tela automaticamente!
+`.trim()
+        }
+      ],
+      structuredData: {
+        success: true,
+        jobId: job.id,
+        status: "completed",
+        type: job.type
+      }
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u274C Erro ao submeter resultado para o job "${input.jobId}": ${err.message}`
+        }
+      ],
+      structuredData: {
+        success: false,
+        error: err.message
+      }
+    };
+  }
+}
+
 // src/server.ts
 function createLinkeGringoMcpServer() {
   const server = new McpServer({
@@ -1375,13 +1435,23 @@ function createLinkeGringoMcpServer() {
     }
   );
   server.registerTool(
-    "check_chrome_cdp_status",
+    "get_pending_job",
     {
-      description: "Verifica se o Google Chrome est\xE1 com a depura\xE7\xE3o remota (CDP) ativada (via chrome://inspect/#remote-debugging ou porta 9222) e lista as abas dispon\xEDveis, verificando se o LinkeGringo est\xE1 aberto.",
-      inputSchema: checkChromeCdpInputSchema.shape
+      description: "Busca o pr\xF3ximo job pendente enviado pela interface gr\xE1fica web do LinkeGringo (ex: upload de perfil para diagn\xF3stico, gera\xE7\xE3o de entrevista, reescrita de perfil).",
+      inputSchema: getPendingJobInputSchema.shape
     },
     async (args) => {
-      return await handleCheckChromeCdp(args);
+      return await handleGetPendingJob(args);
+    }
+  );
+  server.registerTool(
+    "submit_job_result",
+    {
+      description: "Envia o resultado processado pelo agente de IA de volta para a interface gr\xE1fica web do LinkeGringo, desbloqueando o front-end e atualizando a tela imediatamente.",
+      inputSchema: submitJobResultInputSchema.shape
+    },
+    async (args) => {
+      return await handleSubmitJobResult(args);
     }
   );
   server.registerResource(
@@ -1422,49 +1492,49 @@ function createLinkeGringoMcpServer() {
 }
 
 // src/cli/installer.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
+import fs from "fs";
+import path from "path";
+import os from "os";
 function getMcpConfigsForSystem() {
-  const home = os2.homedir();
-  const platform = os2.platform();
+  const home = os.homedir();
+  const platform = os.platform();
   const configs = [];
-  const antigravityPath = path2.join(home, ".gemini", "config", "mcp_config.json");
+  const antigravityPath = path.join(home, ".gemini", "config", "mcp_config.json");
   configs.push({
     id: "antigravity",
     client: "Google Antigravity",
     configPath: antigravityPath,
-    detected: fs2.existsSync(path2.join(home, ".gemini")) || fs2.existsSync(antigravityPath)
+    detected: fs.existsSync(path.join(home, ".gemini")) || fs.existsSync(antigravityPath)
   });
   let claudePath;
   let claudeDir;
   if (platform === "darwin") {
-    claudeDir = path2.join(home, "Library", "Application Support", "Claude");
-    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path.join(home, "Library", "Application Support", "Claude");
+    claudePath = path.join(claudeDir, "claude_desktop_config.json");
   } else if (platform === "win32") {
-    claudeDir = path2.join(process.env.APPDATA || path2.join(home, "AppData", "Roaming"), "Claude");
-    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "Claude");
+    claudePath = path.join(claudeDir, "claude_desktop_config.json");
   } else {
-    claudeDir = path2.join(home, ".config", "Claude");
-    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path.join(home, ".config", "Claude");
+    claudePath = path.join(claudeDir, "claude_desktop_config.json");
   }
   configs.push({
     id: "claude",
     client: `Claude Desktop (${platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : "Linux"})`,
     configPath: claudePath,
-    detected: fs2.existsSync(claudeDir) || fs2.existsSync(claudePath)
+    detected: fs.existsSync(claudeDir) || fs.existsSync(claudePath)
   });
-  const cursorDir = path2.join(home, ".cursor");
-  const cursorPath = path2.join(cursorDir, "mcp.json");
+  const cursorDir = path.join(home, ".cursor");
+  const cursorPath = path.join(cursorDir, "mcp.json");
   configs.push({
     id: "cursor",
     client: "Cursor AI",
     configPath: cursorPath,
-    detected: fs2.existsSync(cursorDir) || fs2.existsSync(cursorPath)
+    detected: fs.existsSync(cursorDir) || fs.existsSync(cursorPath)
   });
-  const windsurfDir = path2.join(home, ".codeium", "windsurf");
-  const windsurfPath = path2.join(windsurfDir, "mcp_config.json");
-  if (fs2.existsSync(windsurfDir) || fs2.existsSync(windsurfPath)) {
+  const windsurfDir = path.join(home, ".codeium", "windsurf");
+  const windsurfPath = path.join(windsurfDir, "mcp_config.json");
+  if (fs.existsSync(windsurfDir) || fs.existsSync(windsurfPath)) {
     configs.push({
       id: "windsurf",
       client: "Windsurf",
@@ -1475,15 +1545,15 @@ function getMcpConfigsForSystem() {
   return configs;
 }
 function installMcpServerConfig(configPath) {
-  const dir = path2.dirname(configPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
   let configData = { mcpServers: {} };
   let isNew = true;
-  if (fs2.existsSync(configPath)) {
+  if (fs.existsSync(configPath)) {
     try {
-      const raw = fs2.readFileSync(configPath, "utf8");
+      const raw = fs.readFileSync(configPath, "utf8");
       if (raw.trim()) {
         configData = JSON.parse(raw);
         isNew = false;
@@ -1499,11 +1569,7 @@ function installMcpServerConfig(configPath) {
     command: "npx",
     args: ["-y", "@linkegringo/mcp"]
   };
-  configData.mcpServers["chrome-devtools"] = {
-    command: "npx",
-    args: ["-y", "chrome-devtools-mcp@latest", "--autoConnect"]
-  };
-  fs2.writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n", "utf8");
+  fs.writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n", "utf8");
   return {
     status: isNew ? "created" : "updated",
     path: configPath
@@ -1531,8 +1597,8 @@ function runInstaller(args = process.argv) {
   const results = [];
   if (options.local) {
     const cwd = process.cwd();
-    const localCursorDir = path2.join(cwd, ".cursor");
-    const localPath = path2.join(localCursorDir, "mcp.json");
+    const localCursorDir = path.join(cwd, ".cursor");
+    const localPath = path.join(localCursorDir, "mcp.json");
     try {
       const res = installMcpServerConfig(localPath);
       results.push({
@@ -1604,14 +1670,393 @@ function runInstaller(args = process.argv) {
   return results;
 }
 
+// src/bridge/server.ts
+import http from "http";
+function setCorsHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  res.setHeader("Access-Control-Max-Age", "86400");
+}
+function sendJson(res, statusCode, data) {
+  setCorsHeaders(res);
+  res.writeHead(statusCode, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+async function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > 50 * 1024 * 1024) {
+        req.destroy();
+        reject(new Error("Payload too large"));
+      }
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function createBridgeHttpServer(options = {}) {
+  const server = http.createServer(async (req, res) => {
+    setCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const pathname = parsedUrl.pathname;
+    try {
+      if (req.method === "GET" && (pathname === "/health" || pathname === "/api/health")) {
+        sendJson(res, 200, {
+          status: "ok",
+          server: "linkegringo-mcp-bridge",
+          watcherConnected: bridgeJobStore.hasActiveWatcher(),
+          watcherCount: bridgeJobStore.getWatcherCount(),
+          pendingCount: bridgeJobStore.getPendingCount(),
+          totalJobs: bridgeJobStore.getAllJobs().length
+        });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/bridge/status") {
+        const pendingJob = bridgeJobStore.getPendingJob();
+        sendJson(res, 200, {
+          ok: true,
+          status: "ready",
+          server: "linkegringo-mcp-bridge",
+          watcherConnected: bridgeJobStore.hasActiveWatcher(),
+          watcherCount: bridgeJobStore.getWatcherCount(),
+          pendingCount: bridgeJobStore.getPendingCount(),
+          activeJobId: pendingJob ? pendingJob.id : null,
+          totalJobs: bridgeJobStore.getAllJobs().length
+        });
+        return;
+      }
+      if (req.method === "POST" && pathname === "/api/bridge/disconnect") {
+        const canceledCount = bridgeJobStore.cancelAllPending("Cancelado pelo usu\xE1rio na interface web.");
+        sendJson(res, 200, {
+          ok: true,
+          message: "Conex\xE3o cancelada e fila de jobs limpa com sucesso.",
+          canceledCount
+        });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/jobs/stream") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache, no-transform",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.flushHeaders?.();
+        const watcherId = `watcher_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        bridgeJobStore.registerWatcher(watcherId);
+        res.write(`data: ${JSON.stringify({ type: "connected", watcherId, pendingCount: bridgeJobStore.getPendingCount() })}
+
+`);
+        const onJobCreated = (job) => {
+          res.write(`data: ${JSON.stringify({ type: "job_created", job: { id: job.id, type: job.type, createdAt: job.createdAt } })}
+
+`);
+        };
+        const onJobCompleted = (job) => {
+          res.write(`data: ${JSON.stringify({ type: "job_completed", job: { id: job.id, type: job.type } })}
+
+`);
+        };
+        const onJobFailed = (job) => {
+          res.write(`data: ${JSON.stringify({ type: "job_failed", job: { id: job.id, type: job.type, error: job.error } })}
+
+`);
+        };
+        bridgeJobStore.on("job:created", onJobCreated);
+        bridgeJobStore.on("job:completed", onJobCompleted);
+        bridgeJobStore.on("job:failed", onJobFailed);
+        const heartbeat = setInterval(() => {
+          res.write(`: heartbeat
+
+`);
+        }, 15e3);
+        req.on("close", () => {
+          clearInterval(heartbeat);
+          bridgeJobStore.unregisterWatcher(watcherId);
+          bridgeJobStore.off("job:created", onJobCreated);
+          bridgeJobStore.off("job:completed", onJobCompleted);
+          bridgeJobStore.off("job:failed", onJobFailed);
+        });
+        return;
+      }
+      if (req.method === "POST" && pathname === "/api/jobs") {
+        const body = await parseBody(req);
+        if (!body.type) {
+          sendJson(res, 400, { ok: false, error: 'Campo "type" \xE9 obrigat\xF3rio.' });
+          return;
+        }
+        const job = bridgeJobStore.createJob(body.type, body.payload || {});
+        options.onJobCreated?.(job);
+        sendJson(res, 201, { ok: true, job });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/jobs") {
+        sendJson(res, 200, { ok: true, jobs: bridgeJobStore.getAllJobs() });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/jobs/pending") {
+        const id = parsedUrl.searchParams.get("id") || void 0;
+        const job = bridgeJobStore.getPendingJob(id);
+        sendJson(res, 200, { ok: true, job: job || null });
+        return;
+      }
+      const jobMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)$/);
+      if (req.method === "GET" && jobMatch) {
+        const jobId = jobMatch[1];
+        const wait = parsedUrl.searchParams.get("wait") === "true";
+        const timeout = parseInt(parsedUrl.searchParams.get("timeout") || "30000", 10);
+        let job = bridgeJobStore.getJob(jobId);
+        if (!job) {
+          sendJson(res, 404, { ok: false, error: `Job n\xE3o encontrado: ${jobId}` });
+          return;
+        }
+        if (wait && (job.status === "pending" || job.status === "processing")) {
+          try {
+            job = await bridgeJobStore.waitForJob(jobId, timeout);
+          } catch {
+            job = bridgeJobStore.getJob(jobId) || job;
+          }
+        }
+        sendJson(res, 200, { ok: true, job });
+        return;
+      }
+      const completeMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)\/complete$/);
+      if (req.method === "POST" && completeMatch) {
+        const jobId = completeMatch[1];
+        const body = await parseBody(req);
+        try {
+          const job = bridgeJobStore.completeJob(jobId, body.result);
+          sendJson(res, 200, { ok: true, job });
+        } catch (err) {
+          sendJson(res, 404, { ok: false, error: err.message });
+        }
+        return;
+      }
+      const failMatch = pathname.match(/^\/api\/jobs\/([a-zA-Z0-9_-]+)\/fail$/);
+      if (req.method === "POST" && failMatch) {
+        const jobId = failMatch[1];
+        const body = await parseBody(req);
+        try {
+          const job = bridgeJobStore.failJob(jobId, body.error || "Erro desconhecido");
+          sendJson(res, 200, { ok: true, job });
+        } catch (err) {
+          sendJson(res, 404, { ok: false, error: err.message });
+        }
+        return;
+      }
+      if (req.method === "POST" && pathname === "/api/jobs/clear") {
+        bridgeJobStore.clear();
+        sendJson(res, 200, { ok: true, message: "Fila de jobs limpa com sucesso." });
+        return;
+      }
+      sendJson(res, 404, { ok: false, error: "Rota n\xE3o encontrada" });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err?.message || "Erro interno no servidor bridge" });
+    }
+  });
+  return server;
+}
+var activeBridgeServer = null;
+var activePort = 5174;
+async function startBridgeServer(options = {}) {
+  if (activeBridgeServer) {
+    return {
+      server: activeBridgeServer,
+      port: activePort,
+      close: stopBridgeServer
+    };
+  }
+  const port = options.port || parseInt(process.env.LINKEGRINGO_BRIDGE_PORT || "5174", 10);
+  const host = options.host || "127.0.0.1";
+  const server = createBridgeHttpServer(options);
+  return new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(`[LinkeGringo Bridge] Porta ${port} j\xE1 est\xE1 em uso. Reutilizando porta existente.`);
+        resolve({
+          server,
+          port,
+          close: stopBridgeServer
+        });
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, host, () => {
+      activeBridgeServer = server;
+      activePort = port;
+      console.error(`[LinkeGringo Bridge] Servidor HTTP local ativo em http://${host}:${port}`);
+      resolve({
+        server,
+        port,
+        close: stopBridgeServer
+      });
+    });
+  });
+}
+async function stopBridgeServer() {
+  if (!activeBridgeServer) return;
+  return new Promise((resolve) => {
+    activeBridgeServer?.close(() => {
+      activeBridgeServer = null;
+      resolve();
+    });
+  });
+}
+
+// src/bridge/watcher.ts
+import http2 from "http";
+function startBridgeWatcher(options = {}) {
+  const bridgeUrl = options.bridgeUrl || process.env.LINKEGRINGO_BRIDGE_URL || "http://127.0.0.1:5174";
+  let isClosed = false;
+  let currentReq = null;
+  let retryTimer = null;
+  let retryDelay = 1e3;
+  function connect() {
+    if (isClosed) return;
+    try {
+      const url = new URL("/api/jobs/stream", bridgeUrl);
+      const req = http2.get(
+        url.toString(),
+        {
+          headers: {
+            Accept: "text/event-stream",
+            "Cache-Control": "no-cache"
+          }
+        },
+        (res) => {
+          if (res.statusCode !== 200) {
+            options.onError?.(new Error(`Falha ao conectar no stream SSE: HTTP ${res.statusCode}`));
+            scheduleRetry();
+            return;
+          }
+          retryDelay = 1e3;
+          let buffer = "";
+          res.on("data", (chunk) => {
+            buffer += chunk.toString("utf-8");
+            const lines = buffer.split("\n\n");
+            buffer = lines.pop() || "";
+            for (const block of lines) {
+              for (const line of block.split("\n")) {
+                if (line.startsWith("data: ")) {
+                  try {
+                    const payload = JSON.parse(line.slice(6));
+                    if (payload.type === "connected") {
+                      options.onConnect?.(payload);
+                      console.log(
+                        `[LinkeGringo Watcher] \u{1F7E2} Conectado ao bridge (${bridgeUrl}). Watcher ativo: ${payload.watcherId} (Jobs pendentes: ${payload.pendingCount})`
+                      );
+                      if (options.once && payload.pendingCount > 0) {
+                        console.log(
+                          `[LinkeGringo Watcher] \u{1F680} JOB DETECTADO NA FILA (${payload.pendingCount} pendente(s)). Finalizando para ativar agente...`
+                        );
+                        setTimeout(() => process.exit(0), 50);
+                      }
+                    } else if (payload.type === "job_created") {
+                      console.log(
+                        `
+[LinkeGringo Watcher] \u{1F680} NOVO JOB DETECTADO: ${payload.job.id} | Tipo: ${payload.job.type}`
+                      );
+                      options.onJob?.(payload.job);
+                      if (options.once) {
+                        setTimeout(() => process.exit(0), 50);
+                      }
+                    } else if (payload.type === "job_completed") {
+                      console.log(`[LinkeGringo Watcher] \u2705 Job finalizado: ${payload.job.id}`);
+                    } else if (payload.type === "job_failed") {
+                      console.log(
+                        `[LinkeGringo Watcher] \u26A0\uFE0F Job cancelado ou com erro: ${payload.job.id} (${payload.job.error})`
+                      );
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          });
+          res.on("end", () => {
+            if (!isClosed) {
+              scheduleRetry();
+            }
+          });
+          res.on("error", (err) => {
+            options.onError?.(err);
+            if (!isClosed) {
+              scheduleRetry();
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        options.onError?.(err);
+        if (!isClosed) {
+          scheduleRetry();
+        }
+      });
+      currentReq = req;
+    } catch (err) {
+      options.onError?.(err);
+      scheduleRetry();
+    }
+  }
+  function scheduleRetry() {
+    if (isClosed || retryTimer) return;
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      retryDelay = Math.min(retryDelay * 1.5, 1e4);
+      connect();
+    }, retryDelay);
+  }
+  connect();
+  return {
+    close() {
+      isClosed = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      if (currentReq) {
+        currentReq.destroy();
+        currentReq = null;
+      }
+      console.log("[LinkeGringo Watcher] Modo watch desconectado.");
+    }
+  };
+}
+
 // src/index.ts
-import fs3 from "fs";
+import fs2 from "fs";
 import { fileURLToPath } from "url";
 async function main() {
   if (process.argv.includes("install") || process.argv.includes("setup") || process.argv.includes("--install")) {
     runInstaller(process.argv);
     return;
   }
+  if (process.argv.includes("watch") || process.argv.includes("--watch") || process.argv.includes("listen")) {
+    const once = process.argv.includes("--once") || process.argv.includes("-1");
+    console.log(`[LinkeGringo Watcher] Iniciando modo escuta ultraleve${once ? " (once)" : ""}...`);
+    startBridgeWatcher({ once });
+    return;
+  }
+  try {
+    await startBridgeServer();
+  } catch (err) {
+    console.error("[LinkeGringo Bridge] N\xE3o foi poss\xEDvel iniciar bridge HTTP:", err);
+  }
   const server = createLinkeGringoMcpServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -1621,7 +2066,7 @@ function isDirectExecution() {
   if (!process.argv[1]) return false;
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    const scriptPath = fs3.existsSync(process.argv[1]) ? fs3.realpathSync(process.argv[1]) : process.argv[1];
+    const scriptPath = fs2.existsSync(process.argv[1]) ? fs2.realpathSync(process.argv[1]) : process.argv[1];
     return currentFilePath === scriptPath || process.argv[1].endsWith("index.js") || process.argv[1].endsWith("linkegringo-mcp") || process.argv[1].endsWith("mcp") || process.argv[1].endsWith("linkegringo");
   } catch {
     return true;
@@ -1635,25 +2080,31 @@ if (isDirectExecution()) {
 }
 export {
   auditProfileInputSchema,
-  checkChromeCdp,
-  checkChromeCdpInputSchema,
+  bridgeJobStore,
+  completeRemoteOrLocalJob,
   convertToXyzBulletInputSchema,
+  createBridgeHttpServer,
   createLinkeGringoMcpServer,
   detectSparseExperiences,
-  findDevToolsActivePort,
+  failRemoteOrLocalJob,
   formatGoogleXyzBullet,
   generateHeadlineInputSchema,
   getExperienceBulletCount,
   getMcpConfigsForSystem,
+  getPendingJobInputSchema,
+  getRemoteOrLocalPendingJob,
   handleAuditProfile,
-  handleCheckChromeCdp,
   handleConvertToXyzBullet,
   handleGenerateHeadline,
+  handleGetPendingJob,
   handleSimulateRecruiterSearch,
+  handleSubmitJobResult,
   installMcpServerConfig,
-  isLinkeGringoUrl,
   parseArgs,
-  probeViaWebSocket,
   runInstaller,
-  simulateRecruiterSearchInputSchema
+  simulateRecruiterSearchInputSchema,
+  startBridgeServer,
+  startBridgeWatcher,
+  stopBridgeServer,
+  submitJobResultInputSchema
 };