@linkegringo/mcp 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { Experience } from '@linkegringo/core';
 
 declare function createLinkeGringoMcpServer(): McpServer;
 
@@ -19,23 +21,50 @@ interface ChromeTabInfo {
     webSocketDebuggerUrl?: string;
     devtoolsFrontendUrl?: string;
 }
+interface LinkeGringoTabInfo {
+    id: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+}
+interface LinkeGringoSessionState {
+    hasUploadedProfile: boolean;
+    candidateName?: string;
+    targetRole?: string;
+    step?: string;
+    inboundScore?: number;
+    profile?: any;
+    review?: any;
+}
 interface CdpStatus {
     isRunning: boolean;
     port: number;
     host: string;
     browser?: string;
     protocolVersion?: string;
-    activeTabs: Array<{
-        id: string;
-        title: string;
-        url: string;
-        webSocketDebuggerUrl?: string;
-    }>;
+    /**
+     * Abas ativas restritas estritamente ao escopo do LinkeGringo (Privacy Shield).
+     * Abas pessoais (e-mails, mensageiros, bancos) são completamente omitidas.
+     */
+    activeTabs: LinkeGringoTabInfo[];
+    linkeGringoTabs: LinkeGringoTabInfo[];
+    otherTabsCount: number;
     linkeGringoTabFound: boolean;
     linkeGringoTabUrl?: string;
+    sessionState?: LinkeGringoSessionState | null;
     error?: string;
 }
 
+declare function isLinkeGringoUrl(url?: string): boolean;
+declare function findDevToolsActivePort(): {
+    port: number;
+    wsPath: string;
+} | null;
+declare function probeViaWebSocket(port: number, wsPath: string, timeoutMs?: number): Promise<{
+    linkeGringoTabs: LinkeGringoTabInfo[];
+    otherTabsCount: number;
+    sessionState: LinkeGringoSessionState | null;
+} | null>;
 declare function checkChromeCdp(port?: number, host?: string, timeoutMs?: number): Promise<CdpStatus>;
 
 interface McpTarget {
@@ -63,4 +92,281 @@ declare function installMcpServerConfig(configPath: string): {
 declare function parseArgs(args?: string[]): InstallerOptions;
 declare function runInstaller(args?: string[]): InstallResult[];
 
-export { type CdpStatus, type ChromeTabInfo, type ChromeVersionResponse, type InstallResult, type InstallerOptions, type McpTarget, checkChromeCdp, createLinkeGringoMcpServer, getMcpConfigsForSystem, installMcpServerConfig, parseArgs, runInstaller };
+interface SparseExperience {
+    company: string;
+    title: string;
+    estimatedBullets: number;
+}
+declare function getExperienceBulletCount(exp: {
+    description?: string;
+    bullets?: string[];
+}): number;
+declare function detectSparseExperiences(experiences?: Experience[]): SparseExperience[];
+declare const auditProfileInputSchema: z.ZodObject<{
+    profileText: z.ZodOptional<z.ZodString>;
+    headline: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    experiences: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        company: z.ZodString;
+        title: z.ZodString;
+        bullets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        company: string;
+        description?: string | undefined;
+        bullets?: string[] | undefined;
+    }, {
+        title: string;
+        company: string;
+        description?: string | undefined;
+        bullets?: string[] | undefined;
+    }>, "many">>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    targetRole: z.ZodDefault<z.ZodString>;
+    targetMarket: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    targetMarket: string;
+    targetRole: string;
+    headline?: string | undefined;
+    summary?: string | undefined;
+    experiences?: {
+        title: string;
+        company: string;
+        description?: string | undefined;
+        bullets?: string[] | undefined;
+    }[] | undefined;
+    skills?: string[] | undefined;
+    profileText?: string | undefined;
+}, {
+    headline?: string | undefined;
+    summary?: string | undefined;
+    experiences?: {
+        title: string;
+        company: string;
+        description?: string | undefined;
+        bullets?: string[] | undefined;
+    }[] | undefined;
+    skills?: string[] | undefined;
+    targetMarket?: string | undefined;
+    targetRole?: string | undefined;
+    profileText?: string | undefined;
+}>;
+type AuditProfileInput = z.infer<typeof auditProfileInputSchema>;
+interface AuditIssue {
+    severity: 'critical' | 'warning' | 'info';
+    category: 'headline' | 'experience' | 'about' | 'skills';
+    message: string;
+    recommendation: string;
+}
+declare function handleAuditProfile(input: AuditProfileInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        status: string;
+        linkeGringoTabUrl: string | undefined;
+        message: string;
+        actionRequired: string;
+        score?: undefined;
+        targetRole?: undefined;
+        headline?: undefined;
+        totalBullets?: undefined;
+        bulletsWithMetrics?: undefined;
+        sparseExperiences?: undefined;
+        triageBottlenecks?: undefined;
+        issues?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        status: string;
+        message: string;
+        actionRequired: string;
+        linkeGringoTabUrl?: undefined;
+        score?: undefined;
+        targetRole?: undefined;
+        headline?: undefined;
+        totalBullets?: undefined;
+        bulletsWithMetrics?: undefined;
+        sparseExperiences?: undefined;
+        triageBottlenecks?: undefined;
+        issues?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        score: number;
+        targetRole: string;
+        headline: string;
+        totalBullets: number;
+        bulletsWithMetrics: number;
+        sparseExperiences: SparseExperience[];
+        triageBottlenecks: string[];
+        issues: AuditIssue[];
+        status?: undefined;
+        linkeGringoTabUrl?: undefined;
+        message?: undefined;
+        actionRequired?: undefined;
+    };
+}>;
+
+declare const simulateRecruiterSearchInputSchema: z.ZodObject<{
+    headline: z.ZodString;
+    summary: z.ZodDefault<z.ZodString>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    experienceBullets: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    targetRole: z.ZodDefault<z.ZodString>;
+    requiredKeywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    headline: string;
+    summary: string;
+    skills: string[];
+    targetRole: string;
+    experienceBullets: string[];
+    requiredKeywords?: string[] | undefined;
+}, {
+    headline: string;
+    summary?: string | undefined;
+    skills?: string[] | undefined;
+    targetRole?: string | undefined;
+    experienceBullets?: string[] | undefined;
+    requiredKeywords?: string[] | undefined;
+}>;
+type SimulateRecruiterSearchInput = z.infer<typeof simulateRecruiterSearchInputSchema>;
+declare function handleSimulateRecruiterSearch(input: SimulateRecruiterSearchInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        overallStatus: "weak" | "missing" | "match";
+        matchPercentage: number;
+        evaluations: {
+            term: string;
+            status: "weak" | "missing" | "match";
+            detail: string;
+        }[];
+        matchCount: number;
+        weakCount: number;
+        missingCount: number;
+    };
+}>;
+
+declare const convertToXyzBulletInputSchema: z.ZodObject<{
+    rawBullet: z.ZodString;
+    roleContext: z.ZodDefault<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+    metric: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    rawBullet: string;
+    roleContext: string;
+    method?: string | undefined;
+    metric?: string | undefined;
+    action?: string | undefined;
+}, {
+    rawBullet: string;
+    method?: string | undefined;
+    metric?: string | undefined;
+    roleContext?: string | undefined;
+    action?: string | undefined;
+}>;
+type ConvertToXyzBulletInput = z.infer<typeof convertToXyzBulletInputSchema>;
+declare function formatGoogleXyzBullet(parts: {
+    action: string;
+    metric: string;
+    method: string;
+}): string;
+declare function handleConvertToXyzBullet(input: ConvertToXyzBulletInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        formattedBullet: string;
+        parts: {
+            action: string;
+            metric: string;
+            method: string;
+        };
+        hasMetrics?: undefined;
+        rawBullet?: undefined;
+        proposals?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        hasMetrics: boolean;
+        rawBullet: string;
+        proposals: string[];
+        formattedBullet?: undefined;
+        parts?: undefined;
+    };
+}>;
+
+declare const generateHeadlineInputSchema: z.ZodObject<{
+    targetRole: z.ZodDefault<z.ZodString>;
+    coreTechnologies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    keyDifferentiator: z.ZodOptional<z.ZodString>;
+    seniorityOrScope: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    targetRole: string;
+    coreTechnologies: string[];
+    seniorityOrScope: string;
+    keyDifferentiator?: string | undefined;
+}, {
+    targetRole?: string | undefined;
+    coreTechnologies?: string[] | undefined;
+    keyDifferentiator?: string | undefined;
+    seniorityOrScope?: string | undefined;
+}>;
+type GenerateHeadlineInput = z.infer<typeof generateHeadlineInputSchema>;
+declare function handleGenerateHeadline(input: GenerateHeadlineInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: {
+        proposals: {
+            type: string;
+            headline: string;
+            charCount: number;
+            focus: string;
+        }[];
+    };
+}>;
+
+declare const checkChromeCdpInputSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    host: z.ZodDefault<z.ZodString>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    host: string;
+    timeoutMs: number;
+}, {
+    port?: number | undefined;
+    host?: string | undefined;
+    timeoutMs?: number | undefined;
+}>;
+type CheckChromeCdpInput = z.infer<typeof checkChromeCdpInputSchema>;
+declare function handleCheckChromeCdp(input: CheckChromeCdpInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredData: CdpStatus;
+}>;
+
+export { type AuditIssue, type AuditProfileInput, type CdpStatus, type CheckChromeCdpInput, type ChromeTabInfo, type ChromeVersionResponse, type ConvertToXyzBulletInput, type GenerateHeadlineInput, type InstallResult, type InstallerOptions, type LinkeGringoSessionState, type LinkeGringoTabInfo, type McpTarget, type SimulateRecruiterSearchInput, type SparseExperience, auditProfileInputSchema, checkChromeCdp, checkChromeCdpInputSchema, convertToXyzBulletInputSchema, createLinkeGringoMcpServer, detectSparseExperiences, findDevToolsActivePort, formatGoogleXyzBullet, generateHeadlineInputSchema, getExperienceBulletCount, getMcpConfigsForSystem, handleAuditProfile, handleCheckChromeCdp, handleConvertToXyzBullet, handleGenerateHeadline, handleSimulateRecruiterSearch, installMcpServerConfig, isLinkeGringoUrl, parseArgs, probeViaWebSocket, runInstaller, simulateRecruiterSearchInputSchema };

package/dist/index.js

@@ -8,6 +8,233 @@ 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 {
+      }
+    }
+  }
+  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 {
+      }
+      resolve(null);
+    }, timeoutMs);
+    try {
+      ws = new globalThis.WebSocket(wsUrl);
+    } catch {
+      clearTimeout(timer);
+      resolve(null);
+      return;
+    }
+    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;
+          try {
+            if (raw) session = JSON.parse(raw);
+          } 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
+          });
+        }
+      } 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
+      };
+    }
+  }
+  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 = [];
+    try {
+      const listRes = await fetch(`http://${host}:${port}/json/list`, {
+        signal: controller.signal
+      });
+      if (listRes.ok) {
+        const rawTabs = await listRes.json();
+        if (Array.isArray(rawTabs)) {
+          pageTabs = rawTabs.filter((t) => t.type === "page");
+        }
+      }
+    } 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);
+  }
+}
+
+// src/tools/audit-profile.ts
 function getExperienceBulletCount(exp) {
   if (Array.isArray(exp.bullets) && exp.bullets.length > 0) {
     return exp.bullets.length;
@@ -57,7 +284,77 @@ async function handleAuditProfile(input) {
   let headline = input.headline || "";
   let summary = input.summary || "";
   let skills = input.skills || [];
-  const rawExperiences = input.experiences || [];
+  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
+
+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**.
+
+---
+
+### \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!
+`.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: `
+# \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.
+
+### 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\`.
+`.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"
+          }
+        };
+      }
+    } catch {
+    }
+  }
   if (input.profileText && !headline && rawExperiences.length === 0) {
     const lines = input.profileText.split("\n").map((l) => l.trim()).filter(Boolean);
     if (lines.length > 0) {
@@ -960,89 +1257,57 @@ ${proposals.map(
 
 // src/tools/cdp-check.ts
 import { z as z11 } from "zod";
-
-// src/cdp/probe.ts
-async function checkChromeCdp(port = 9222, host = "127.0.0.1", timeoutMs = 2e3) {
-  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 = [];
-    try {
-      const listRes = await fetch(`http://${host}:${port}/json/list`, {
-        signal: controller.signal
-      });
-      if (listRes.ok) {
-        const rawTabs = await listRes.json();
-        if (Array.isArray(rawTabs)) {
-          pageTabs = rawTabs.filter((t) => t.type === "page");
-        }
-      }
-    } catch {
-    }
-    const linkeGringoTab = pageTabs.find((t) => {
-      const lowerUrl = (t.url || "").toLowerCase();
-      return lowerUrl.includes("linkegringo") || lowerUrl.includes("5173") || lowerUrl.includes("muriel-gasparini.github.io");
-    });
-    return {
-      isRunning: true,
-      port,
-      host,
-      browser: versionData.Browser,
-      protocolVersion: versionData["Protocol-Version"],
-      activeTabs: pageTabs.map((t) => ({
-        id: t.id,
-        title: t.title,
-        url: t.url,
-        webSocketDebuggerUrl: t.webSocketDebuggerUrl
-      })),
-      linkeGringoTabFound: Boolean(linkeGringoTab),
-      linkeGringoTabUrl: linkeGringoTab?.url
-    };
-  } catch (err) {
-    const error = err;
-    const isTimeout = error.name === "AbortError" || error.name === "TimeoutError";
-    return {
-      isRunning: false,
-      port,
-      host,
-      activeTabs: [],
-      linkeGringoTabFound: false,
-      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);
-  }
-}
-
-// src/tools/cdp-check.ts
 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(2e3).describe("Tempo limite em milissegundos para a conex\xE3o")
+  timeoutMs: z11.number().default(5e3).describe("Tempo limite em milissegundos para a conex\xE3o")
 });
 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.
+`;
+  }
   const markdownSummary = `
-# Status do Chrome Remote Debugging (CDP)
+# Status do Chrome Remote Debugging (CDP) & LinkeGringo
 
-**Porta Testada**: ${status.host}:${status.port}
-**Status da Conex\xE3o**: ${status.isRunning ? "\u{1F7E2} Conectado e Ativo" : "\u{1F534} Desconectado"}
+**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 || "Desconhecido"}
-- **Vers\xE3o do Protocolo DevTools**: ${status.protocolVersion || "1.3"}
-- **Total de Abas Abertas**: ${status.activeTabs.length}
-- **Aba do LinkeGringo**: ${status.linkeGringoTabFound ? `\u2713 Detectada (${status.linkeGringoTabUrl})` : "\u26A0\uFE0F Nenhuma aba do LinkeGringo aberta no momento"}
+- **Vers\xE3o do Navegador**: ${status.browser || "Google Chrome"}
+- **Aba do LinkeGringo**: ${status.linkeGringoTabFound ? `\u2713 Detectada (\`${status.linkeGringoTabUrl}\`)` : "\u26A0\uFE0F Nenhuma aba do LinkeGringo aberta"}
 
-${status.activeTabs.length > 0 ? `### Abas Encontradas:
-${status.activeTabs.map((t) => `- [${t.title}](${t.url})`).join("\n")}` : ""}
+### \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."}
 > 
@@ -1157,49 +1422,49 @@ function createLinkeGringoMcpServer() {
 }
 
 // src/cli/installer.ts
-import fs from "fs";
-import path from "path";
-import os from "os";
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
 function getMcpConfigsForSystem() {
-  const home = os.homedir();
-  const platform = os.platform();
+  const home = os2.homedir();
+  const platform = os2.platform();
   const configs = [];
-  const antigravityPath = path.join(home, ".gemini", "config", "mcp_config.json");
+  const antigravityPath = path2.join(home, ".gemini", "config", "mcp_config.json");
   configs.push({
     id: "antigravity",
     client: "Google Antigravity",
     configPath: antigravityPath,
-    detected: fs.existsSync(path.join(home, ".gemini")) || fs.existsSync(antigravityPath)
+    detected: fs2.existsSync(path2.join(home, ".gemini")) || fs2.existsSync(antigravityPath)
   });
   let claudePath;
   let claudeDir;
   if (platform === "darwin") {
-    claudeDir = path.join(home, "Library", "Application Support", "Claude");
-    claudePath = path.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path2.join(home, "Library", "Application Support", "Claude");
+    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
   } else if (platform === "win32") {
-    claudeDir = path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "Claude");
-    claudePath = path.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path2.join(process.env.APPDATA || path2.join(home, "AppData", "Roaming"), "Claude");
+    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
   } else {
-    claudeDir = path.join(home, ".config", "Claude");
-    claudePath = path.join(claudeDir, "claude_desktop_config.json");
+    claudeDir = path2.join(home, ".config", "Claude");
+    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
   }
   configs.push({
     id: "claude",
     client: `Claude Desktop (${platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : "Linux"})`,
     configPath: claudePath,
-    detected: fs.existsSync(claudeDir) || fs.existsSync(claudePath)
+    detected: fs2.existsSync(claudeDir) || fs2.existsSync(claudePath)
   });
-  const cursorDir = path.join(home, ".cursor");
-  const cursorPath = path.join(cursorDir, "mcp.json");
+  const cursorDir = path2.join(home, ".cursor");
+  const cursorPath = path2.join(cursorDir, "mcp.json");
   configs.push({
     id: "cursor",
     client: "Cursor AI",
     configPath: cursorPath,
-    detected: fs.existsSync(cursorDir) || fs.existsSync(cursorPath)
+    detected: fs2.existsSync(cursorDir) || fs2.existsSync(cursorPath)
   });
-  const windsurfDir = path.join(home, ".codeium", "windsurf");
-  const windsurfPath = path.join(windsurfDir, "mcp_config.json");
-  if (fs.existsSync(windsurfDir) || fs.existsSync(windsurfPath)) {
+  const windsurfDir = path2.join(home, ".codeium", "windsurf");
+  const windsurfPath = path2.join(windsurfDir, "mcp_config.json");
+  if (fs2.existsSync(windsurfDir) || fs2.existsSync(windsurfPath)) {
     configs.push({
       id: "windsurf",
       client: "Windsurf",
@@ -1210,15 +1475,15 @@ function getMcpConfigsForSystem() {
   return configs;
 }
 function installMcpServerConfig(configPath) {
-  const dir = path.dirname(configPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  const dir = path2.dirname(configPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
   let configData = { mcpServers: {} };
   let isNew = true;
-  if (fs.existsSync(configPath)) {
+  if (fs2.existsSync(configPath)) {
     try {
-      const raw = fs.readFileSync(configPath, "utf8");
+      const raw = fs2.readFileSync(configPath, "utf8");
       if (raw.trim()) {
         configData = JSON.parse(raw);
         isNew = false;
@@ -1238,7 +1503,7 @@ function installMcpServerConfig(configPath) {
     command: "npx",
     args: ["-y", "chrome-devtools-mcp@latest", "--autoConnect"]
   };
-  fs.writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n", "utf8");
+  fs2.writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n", "utf8");
   return {
     status: isNew ? "created" : "updated",
     path: configPath
@@ -1266,8 +1531,8 @@ function runInstaller(args = process.argv) {
   const results = [];
   if (options.local) {
     const cwd = process.cwd();
-    const localCursorDir = path.join(cwd, ".cursor");
-    const localPath = path.join(localCursorDir, "mcp.json");
+    const localCursorDir = path2.join(cwd, ".cursor");
+    const localPath = path2.join(localCursorDir, "mcp.json");
     try {
       const res = installMcpServerConfig(localPath);
       results.push({
@@ -1340,7 +1605,7 @@ function runInstaller(args = process.argv) {
 }
 
 // src/index.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import { fileURLToPath } from "url";
 async function main() {
   if (process.argv.includes("install") || process.argv.includes("setup") || process.argv.includes("--install")) {
@@ -1356,7 +1621,7 @@ function isDirectExecution() {
   if (!process.argv[1]) return false;
   try {
     const currentFilePath = fileURLToPath(import.meta.url);
-    const scriptPath = fs2.existsSync(process.argv[1]) ? fs2.realpathSync(process.argv[1]) : process.argv[1];
+    const scriptPath = fs3.existsSync(process.argv[1]) ? fs3.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;
@@ -1369,10 +1634,26 @@ if (isDirectExecution()) {
   });
 }
 export {
+  auditProfileInputSchema,
   checkChromeCdp,
+  checkChromeCdpInputSchema,
+  convertToXyzBulletInputSchema,
   createLinkeGringoMcpServer,
+  detectSparseExperiences,
+  findDevToolsActivePort,
+  formatGoogleXyzBullet,
+  generateHeadlineInputSchema,
+  getExperienceBulletCount,
   getMcpConfigsForSystem,
+  handleAuditProfile,
+  handleCheckChromeCdp,
+  handleConvertToXyzBullet,
+  handleGenerateHeadline,
+  handleSimulateRecruiterSearch,
   installMcpServerConfig,
+  isLinkeGringoUrl,
   parseArgs,
-  runInstaller
+  probeViaWebSocket,
+  runInstaller,
+  simulateRecruiterSearchInputSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkegringo/mcp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Servidor MCP oficial do LinkeGringo para auditoria e otimização de perfis para o mercado internacional",
   "type": "module",
   "bin": {