@linkegringo/mcp 1.0.2 → 1.0.4

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,39 +21,352 @@ 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 {
+    id: string;
+    client: string;
+    configPath: string;
+    detected: boolean;
+}
 interface InstallResult {
     client: string;
     configPath: string;
     status: 'created' | 'updated' | 'skipped' | 'error';
     message?: string;
 }
-declare function getMcpConfigsForSystem(): Array<{
-    client: string;
-    configPath: string;
-}>;
+interface InstallerOptions {
+    all?: boolean;
+    local?: boolean;
+    client?: string;
+}
+declare function getMcpConfigsForSystem(): McpTarget[];
 declare function installMcpServerConfig(configPath: string): {
     status: 'created' | 'updated';
     path: string;
 };
-declare function runInstaller(): InstallResult[];
+declare function parseArgs(args?: string[]): InstallerOptions;
+declare function runInstaller(args?: string[]): InstallResult[];
+
+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 CdpStatus, type ChromeTabInfo, type ChromeVersionResponse, type InstallResult, checkChromeCdp, createLinkeGringoMcpServer, getMcpConfigsForSystem, installMcpServerConfig, runInstaller };
+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 = 2e3) {
+  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,68 +1257,6 @@ ${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)"),
@@ -1029,20 +1264,50 @@ var checkChromeCdpInputSchema = z11.object({
 });
 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,56 +1422,68 @@ 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 = path2.join(home, ".gemini", "config", "mcp_config.json");
   configs.push({
+    id: "antigravity",
     client: "Google Antigravity",
-    configPath: path.join(home, ".gemini", "config", "mcp_config.json")
+    configPath: antigravityPath,
+    detected: fs2.existsSync(path2.join(home, ".gemini")) || fs2.existsSync(antigravityPath)
   });
+  let claudePath;
+  let claudeDir;
   if (platform === "darwin") {
-    configs.push({
-      client: "Claude Desktop (macOS)",
-      configPath: path.join(
-        home,
-        "Library",
-        "Application Support",
-        "Claude",
-        "claude_desktop_config.json"
-      )
-    });
+    claudeDir = path2.join(home, "Library", "Application Support", "Claude");
+    claudePath = path2.join(claudeDir, "claude_desktop_config.json");
   } else if (platform === "win32") {
-    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
-    configs.push({
-      client: "Claude Desktop (Windows)",
-      configPath: path.join(appData, "Claude", "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 {
-    configs.push({
-      client: "Claude Desktop (Linux)",
-      configPath: path.join(home, ".config", "Claude", "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: fs2.existsSync(claudeDir) || fs2.existsSync(claudePath)
+  });
+  const cursorDir = path2.join(home, ".cursor");
+  const cursorPath = path2.join(cursorDir, "mcp.json");
+  configs.push({
+    id: "cursor",
     client: "Cursor AI",
-    configPath: path.join(home, ".cursor", "mcp.json")
+    configPath: cursorPath,
+    detected: fs2.existsSync(cursorDir) || fs2.existsSync(cursorPath)
   });
+  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",
+      configPath: windsurfPath,
+      detected: true
+    });
+  }
   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;
@@ -1226,19 +1503,74 @@ 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
   };
 }
-function runInstaller() {
+function parseArgs(args = []) {
+  const options = {};
+  for (const arg of args) {
+    if (arg === "--all" || arg === "--force") {
+      options.all = true;
+    } else if (arg === "--local" || arg === "-l") {
+      options.local = true;
+    } else if (arg.startsWith("--client=")) {
+      options.client = arg.split("=")[1]?.toLowerCase().trim();
+    }
+  }
+  return options;
+}
+function runInstaller(args = process.argv) {
   console.log("\n\u{1F680} LinkeGringo MCP - Instalador Autom\xE1tico");
   console.log("================================================");
-  console.log("Configurando servidores em todos os clientes locais:\n");
+  console.log("\u2139\uFE0F  Modo 100% Aut\xF4nomo: N\xE3o requer o c\xF3digo-fonte do LinkeGringo na m\xE1quina.\n");
+  const options = parseArgs(args);
   const targets = getMcpConfigsForSystem();
   const results = [];
+  if (options.local) {
+    const cwd = process.cwd();
+    const localCursorDir = path2.join(cwd, ".cursor");
+    const localPath = path2.join(localCursorDir, "mcp.json");
+    try {
+      const res = installMcpServerConfig(localPath);
+      results.push({
+        client: "Workspace Local (Cursor)",
+        configPath: localPath,
+        status: res.status
+      });
+      console.log(`\u2705 [Workspace Local]`);
+      console.log(`   Arquivo: ${localPath} (${res.status === "created" ? "Criado" : "Atualizado"})
+`);
+    } catch (err) {
+      results.push({
+        client: "Workspace Local",
+        configPath: localPath,
+        status: "error",
+        message: err.message
+      });
+      console.warn(`\u26A0\uFE0F [Workspace Local] Erro ao configurar: ${err.message}
+`);
+    }
+    return results;
+  }
+  const detectedTargets = targets.filter((t) => t.detected);
+  const shouldInstallAll = options.all || detectedTargets.length === 0;
   for (const target of targets) {
+    if (options.client && !target.id.includes(options.client)) {
+      continue;
+    }
+    if (!shouldInstallAll && !target.detected) {
+      results.push({
+        client: target.client,
+        configPath: target.configPath,
+        status: "skipped",
+        message: "Cliente n\xE3o detectado nesta m\xE1quina (use --all para for\xE7ar)"
+      });
+      console.log(`\u23ED\uFE0F  [${target.client}] N\xE3o detectado nesta m\xE1quina (pulado. Use --all para criar)`);
+      continue;
+    }
     try {
       const res = installMcpServerConfig(target.configPath);
       results.push({
@@ -1246,7 +1578,8 @@ function runInstaller() {
         configPath: target.configPath,
         status: res.status
       });
-      console.log(`\u2705 [${target.client}]`);
+      const tag = target.detected ? "(Detectado)" : "(Padr\xE3o)";
+      console.log(`\u2705 [${target.client}] ${tag}`);
       console.log(`   Arquivo: ${target.configPath} (${res.status === "created" ? "Criado" : "Atualizado"})
 `);
     } catch (err) {
@@ -1267,16 +1600,16 @@ function runInstaller() {
   console.log("   \u2022 Claude Code CLI: claude mcp add linkegringo npx -y @linkegringo/mcp");
   console.log('   \u2022 Goose CLI:       goose configure --add-extension "npx -y @linkegringo/mcp"');
   console.log("================================================");
-  console.log("\u{1F389} Instala\xE7\xE3o conclu\xEDda! Reinicie o Claude Desktop, Antigravity ou Cursor para ativar.\n");
+  console.log("\u{1F389} Instala\xE7\xE3o conclu\xEDda! Reinicie o seu cliente de IA para ativar.\n");
   return results;
 }
 
 // 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")) {
-    runInstaller();
+    runInstaller(process.argv);
     return;
   }
   const server = createLinkeGringoMcpServer();
@@ -1288,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;
@@ -1301,9 +1634,26 @@ if (isDirectExecution()) {
   });
 }
 export {
+  auditProfileInputSchema,
   checkChromeCdp,
+  checkChromeCdpInputSchema,
+  convertToXyzBulletInputSchema,
   createLinkeGringoMcpServer,
+  detectSparseExperiences,
+  findDevToolsActivePort,
+  formatGoogleXyzBullet,
+  generateHeadlineInputSchema,
+  getExperienceBulletCount,
   getMcpConfigsForSystem,
+  handleAuditProfile,
+  handleCheckChromeCdp,
+  handleConvertToXyzBullet,
+  handleGenerateHeadline,
+  handleSimulateRecruiterSearch,
   installMcpServerConfig,
-  runInstaller
+  isLinkeGringoUrl,
+  parseArgs,
+  probeViaWebSocket,
+  runInstaller,
+  simulateRecruiterSearchInputSchema
 };

package/package.json

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