@counterfact-labs/cli 0.1.3 → 0.2.3

package/dist/cli/commands/analyze.js

@@ -0,0 +1,73 @@
+import { loadInstalledRelease } from "../../adapters/release.js";
+import { cliRefusals, START_FAILURE_MESSAGE } from "../../contract/cli-refusals.js";
+import { CLI_VERSION } from "../../contract/cli-version.js";
+import { cliApiMessages } from "../../contract/cli-api-messages.js";
+import { ApiError } from "../api.js";
+import { resolveAgentFolder } from "../agent-folder.js";
+import { runRelayCheck } from "../relay-check.js";
+// Only a real pause says "paused"; an unreviewed release or an upload-only server cannot start.
+const unavailable = START_FAILURE_MESSAGE;
+function requireLocal(value) {
+    if (!value || typeof value !== "object" || !("mode" in value) || !("minimumLocalCliVersion" in value)
+        || typeof value.minimumLocalCliVersion !== "string" || !/^\d+\.\d+\.\d+$/.test(value.minimumLocalCliVersion)) {
+        throw new Error(cliApiMessages.invalid_response);
+    }
+    const current = CLI_VERSION.split(".").map(BigInt), minimum = value.minimumLocalCliVersion.split(".").map(BigInt);
+    for (let i = 0; i < current.length; i++) {
+        if (minimum[i] > current[i])
+            throw new ApiError(426, "cli_update_required", cliRefusals.cli_update_required);
+        if (minimum[i] < current[i])
+            break;
+    }
+    if (value.mode === "paused")
+        throw new ApiError(503, "local_checks_paused", cliRefusals.local_checks_paused);
+    // A local-capable client never falls back to sending source files to the hosted upload API.
+    if (value.mode !== "local")
+        throw new ApiError(503, "unavailable", unavailable);
+}
+export async function analyze(path, _options, ctx) {
+    const startup = ctx.startup;
+    requireLocal(await ctx.api.request("checks/mode"));
+    const release = ctx.relayRuntime?.release ?? await loadInstalledRelease();
+    if (release.projectContext !== "checks")
+        throw new Error(unavailable);
+    const token = await ctx.token?.();
+    if (!token)
+        throw new Error("Not signed in. Run counterfact-labs login.");
+    const folder = resolveAgentFolder(path, ctx.cwd);
+    const config = Object.freeze({ ...startup.transport, CF_RELAY_URL: startup.transport.CF_RELAY_URL ?? release.relayUrl,
+        CF_LOCAL_RELAY: "1", CF_CONSOLE_URL: ctx.api.baseUrl, CF_CONSOLE_TOKEN: token });
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.once("SIGINT", cancel);
+    process.once("SIGTERM", cancel);
+    let progressShown = false;
+    const clearProgress = () => { if (progressShown) {
+        ctx.write("\r\u001b[2K");
+        progressShown = false;
+    } };
+    try {
+        return await (ctx.relayRuntime?.run ?? runRelayCheck)(folder, {
+            settings: startup.settings, config, release, connect: ctx.relayRuntime?.connect,
+            signal: ctx.signal ? AbortSignal.any([controller.signal, ctx.signal]) : controller.signal,
+            stdout() { }, stderr() { },
+            onStart: () => { ctx.onCheckStart?.(); ctx.write("\r\u001b[2KAnalyzing the agent…"); progressShown = true; },
+            onError: failure => {
+                clearProgress();
+                ctx.write(`${failure.message}\n`);
+            },
+            onSaved: result => {
+                clearProgress();
+                ctx.onCheckComplete?.(result);
+                if (result.findingIds?.length)
+                    ctx.write(`Finding ids: ${result.findingIds.join(", ")}\n`);
+                ctx.write(`Full results: ${result.url}\n`);
+            },
+        });
+    }
+    finally {
+        clearProgress();
+        process.removeListener("SIGINT", cancel);
+        process.removeListener("SIGTERM", cancel);
+    }
+}

package/dist/cli/commands/login.js

@@ -0,0 +1,51 @@
+import { emailSignInMessages } from "../../contract/email-sign-in-messages.js";
+import { EMAIL_SIGN_IN_TERMS, normalizeSignInEmail, signInWithCode, startEmailSignIn } from "../email-sign-in.js";
+import { startSignIn } from "../sign-in.js";
+export function parseLoginOptions(args) {
+    // The router supplies usage for syntax errors without repeating private arguments.
+    const options = {};
+    for (let index = 0; index < args.length; index += 2) {
+        const flag = args[index];
+        const value = args[index + 1];
+        if ((flag !== "--email" && flag !== "--code") || !value?.trim() || value.startsWith("--"))
+            throw new Error();
+        const key = flag === "--email" ? "email" : "code";
+        if (options[key] !== undefined)
+            throw new Error();
+        options[key] = value;
+    }
+    if (options.code !== undefined && options.email === undefined)
+        throw new Error();
+    return options;
+}
+export async function login(ctx, options = {}) {
+    if (options.email !== undefined) {
+        if (!ctx.startup.emailSignIn)
+            throw new Error(emailSignInMessages.email_unavailable);
+        const email = normalizeSignInEmail(options.email);
+        if (!email)
+            throw new Error(emailSignInMessages.invalid_email);
+        ctx.write(EMAIL_SIGN_IN_TERMS + "\n");
+        let code = options.code;
+        if (code === undefined) {
+            await startEmailSignIn(ctx, email);
+            ctx.write(`We sent a sign-in code to ${email}.\n`);
+            if (!ctx.signInInput.isTerminal) {
+                ctx.write(`To finish signing in, run counterfact-labs login --email ${email} --code <code>.\n`);
+                return 0;
+            }
+            code = await ctx.signInInput.readCode("Enter the code from your email: ", ctx.signal);
+            if (code === undefined)
+                throw new Error(emailSignInMessages.cancelled);
+        }
+        await signInWithCode(ctx, email, code);
+        ctx.write("Signed in.\n");
+        return 0;
+    }
+    const flow = await startSignIn(ctx);
+    ctx.write(`1. Open ${flow.verificationUri}. If asked, sign in with the code we email you.\n`
+        + `2. Then enter this code on that page: ${flow.userCode}\n`);
+    await flow.done;
+    ctx.write("Signed in.\n");
+    return 0;
+}

package/dist/cli/completion-recovery.js

@@ -0,0 +1,18 @@
+export const COMPLETION_SETTINGS_MISMATCH_MESSAGE = "This folder has a saved result for a different Counterfact project or address. Run the analysis again with the original settings to save it, or delete .counterfact/completion.json to start a new analysis.";
+export const matchesCheck = (status, identity) => status.checkId === identity.checkId && status.projectId === identity.projectId;
+export function completionRecoveryDecision(input) {
+    if (input.localMismatch)
+        return { finished: false, message: COMPLETION_SETTINGS_MISMATCH_MESSAGE };
+    if (!input.statusSucceeded)
+        return { finished: false };
+    const { status, completedPayload } = input;
+    // A different analysis cannot settle this saved payload, even when submission reports a conflict.
+    if (status && completedPayload && !matchesCheck(status, completedPayload))
+        return { finished: false };
+    // Only trusted terminal status retires unsaved work; outages and closing work remain retryable.
+    if (status?.uploadState === "missing" && (status.state === "closed" || status.state === "expired")
+        && completedPayload && matchesCheck(status, completedPayload))
+        return { finished: true };
+    // A refusal never retires paid work by itself; only the console's own terminal status above can.
+    return { finished: false };
+}

package/dist/{context.js → cli/context.js}

@@ -1,28 +1,22 @@
+import { readCliSettings } from "../adapters/settings.js";
 import { homedir } from "node:os";
-import { createInterface } from "node:readline/promises";
 import { setTimeout as delay } from "node:timers/promises";
 import { ApiClient, DEFAULT_URL } from "./api.js";
 import { openBrowser } from "./browser.js";
 import { readCredentials } from "./credentials.js";
+import { userEmail } from "./git.js";
+import { terminalSignInInput } from "./sign-in-input.js";
 export function commandContext(options = {}) {
+    const startup = readCliSettings(options.env, options.emailSignIn);
     const homeDir = options.homeDir ?? homedir();
-    const baseUrl = (options.baseUrl ?? process.env.COUNTERFACT_URL ?? DEFAULT_URL).replace(/\/+$/, "");
+    const baseUrl = (options.baseUrl ?? startup.baseUrl ?? DEFAULT_URL).replace(/\/+$/, "");
     const api = new ApiClient(baseUrl, () => readCredentials(homeDir, api.baseUrl), undefined, options.signal);
     const write = options.write ?? (text => { process.stdout.write(text); });
     return {
+        startup, signal: options.signal, relayRuntime: options.relayRuntime, cwd: options.cwd ?? process.cwd(),
+        token: () => readCredentials(homeDir, api.baseUrl), onCheckComplete: options.onCheckComplete, onCheckStart: options.onCheckStart,
         api, homeDir, write, openBrowser: options.openBrowser ?? openBrowser,
+        signInInput: options.signInInput ?? terminalSignInInput(), readEmail: options.readEmail ?? userEmail,
         sleep: options.sleep ?? (async (ms) => { await delay(ms, undefined, { signal: options.signal }); }), now: options.now ?? Date.now,
-        ask: options.ask ?? (async (question) => {
-            if (!process.stdin.isTTY)
-                throw new Error("Use --yes to confirm a check, or --dry-run to see the files and price.");
-            write(question);
-            const input = createInterface({ input: process.stdin });
-            try {
-                return /^(?:y|yes)?$/i.test((await input.question("")).trim());
-            }
-            finally {
-                input.close();
-            }
-        }),
     };
 }

package/dist/cli/email-sign-in.js

@@ -0,0 +1,56 @@
+import { emailSignInMessages } from "../contract/email-sign-in-messages.js";
+import { saveCredentials } from "./credentials.js";
+export const EMAIL_SIGN_IN_TERMS = "By signing in, you agree to our Terms of Service (https://counterfactlabs.com/terms) and Privacy Policy (https://counterfactlabs.com/privacy).";
+function hasControlCharacters(value) {
+    return [...value].some(character => {
+        const code = character.charCodeAt(0);
+        return code < 32 || code === 127;
+    });
+}
+export function normalizeSignInEmail(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const email = value.trim().toLowerCase();
+    if (email.length > 320 || !/^[^@\s]+@[^@\s.]+\.[^@\s]+$/.test(email)
+        || /[<>()[\],:;"\\]/.test(email) || hasControlCharacters(email))
+        return undefined;
+    // ASCII domain labels keep the recipient spelling consistent with the console's mailer.
+    const domain = email.split("@")[1];
+    return /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/.test(domain) ? email : undefined;
+}
+export function validSignInCode(value) {
+    return typeof value === "string" && value.trim().length > 0 && !hasControlCharacters(value.trim()) && !/[\u2028\u2029]/.test(value.trim());
+}
+function requireEmail(value) {
+    const email = normalizeSignInEmail(value);
+    if (!email)
+        throw new Error(emailSignInMessages.invalid_email);
+    return email;
+}
+export async function startEmailSignIn(ctx, email) {
+    const value = await ctx.api.request("email/start", { email: requireEmail(email) }, false);
+    if (!value || typeof value !== "object" || Array.isArray(value) || !("expiresIn" in value)
+        || typeof value.expiresIn !== "number" || !Number.isInteger(value.expiresIn) || value.expiresIn <= 0) {
+        throw new Error(emailSignInMessages.invalid_response);
+    }
+    return { expiresIn: value.expiresIn };
+}
+export async function signInWithCode(ctx, email, code) {
+    const normalizedEmail = requireEmail(email);
+    if (!validSignInCode(code))
+        throw new Error(emailSignInMessages.invalid_code);
+    const value = await ctx.api.request("email/verify", { email: normalizedEmail, code: code.trim(), clientName: "Command line" }, false);
+    if (!value || typeof value !== "object" || Array.isArray(value) || !("token" in value)
+        || typeof value.token !== "string" || !value.token.trim())
+        throw new Error(emailSignInMessages.invalid_response);
+    // A request can complete just as the caller cancels; do not replace a saved sign-in then.
+    if (ctx.signal?.aborted)
+        throw new DOMException(emailSignInMessages.cancelled, "AbortError");
+    try {
+        await saveCredentials(ctx.homeDir, ctx.api.baseUrl, value.token);
+    }
+    catch {
+        throw new Error(emailSignInMessages.request_failed);
+    }
+    return "signed_in";
+}

package/dist/{git.js → cli/git.js}

@@ -1,15 +1,19 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { basename, relative, resolve, sep } from "node:path";
-export async function repositoryFacts(root, git = async (args) => (await promisify(execFile)("git", ["-C", root, ...args], { timeout: 3000, maxBuffer: 16_384 })).stdout) {
-    const folderName = basename(resolve(root));
-    let repoRoot;
+import { gitRepositoryRoot } from "../adapters/repository-root.js";
+import { runGit } from "../adapters/git.js";
+export async function userEmail(folder, git = async (args) => (await runGit(folder, args, { userConfig: true })).toString("utf8")) {
     try {
-        repoRoot = (await git(["rev-parse", "--show-toplevel"])).trim();
+        return await git(["config", "--get", "user.email"]);
     }
     catch {
-        return { remoteUrl: null, relPath: "", folderName, branch: null, commit: null, dirty: null };
+        return undefined;
     }
+}
+export async function repositoryFacts(root, git = async (args) => (await runGit(root, args)).toString("utf8")) {
+    const folderName = basename(resolve(root));
+    const repoRoot = await gitRepositoryRoot(git);
+    if (repoRoot === null)
+        return { remoteUrl: null, relPath: "", folderName, branch: null, commit: null, dirty: null };
     let remoteUrl;
     try {
         remoteUrl = (await git(["config", "--get", "remote.origin.url"])).trim().replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/]*@/i, "$1") || null;
@@ -28,7 +32,7 @@ export async function repositoryFacts(root, git = async (args) => (await promisi
     const [branch, commit, status] = await Promise.all([
         read(["rev-parse", "--abbrev-ref", "HEAD"]), read(["rev-parse", "HEAD"]),
         // Include new files even when Git hides them, and exclude sibling folders.
-        read(["status", "--porcelain", "--untracked-files=normal", "--", "."]),
+        read(["status", "--porcelain=v2", "--no-renames", "--ignore-submodules=all", "--untracked-files=normal", "--", "."]),
     ]);
     return { repoRoot, remoteUrl, relPath: relative(repoRoot, root).split(sep).join("/"), folderName,
         branch: branch === "HEAD" ? null : branch || null, commit: commit || null, dirty: status === null ? null : status.length > 0 };

package/dist/cli/intake-payload.js

@@ -0,0 +1,18 @@
+import { localFindingsPayloadSchema } from "../contract/console.js";
+import { RESULTS_TOO_LARGE_MESSAGE } from "../contract/cli-refusals.js";
+export function buildIntakePayload(identity, agent, report) {
+    const repo = (key) => key === null || key === report.repoKey ? agent.repository : key;
+    const findings = report.findings.map(finding => {
+        // The local report may add presentation fields; the intake accepts cleaned evidence only.
+        const { kind, severity, title, cause, summary, category, question, site, excerpt, otherSites, fixes, sourceNotes } = finding;
+        return { kind, severity, title, cause, summary, category, question, site, excerpt,
+            fixes: fixes.map(({ title, approach, kind, targetFiles, expectedOutcome, summary, impact, confidence, objective, status, blockedBy, alsoFixes, delta }) => ({ title, approach, kind, targetFiles, expectedOutcome, summary, impact, confidence, objective, status, blockedBy, alsoFixes, delta })),
+            siteRepo: repo(finding.siteRepo), otherSites: otherSites.map(site => ({ ...site, repo: repo(site.repo) })),
+            ...(sourceNotes === undefined ? {} : { sourceNotes: sourceNotes && { ...sourceNotes,
+                    counterEvidence: sourceNotes.counterEvidence.map(site => ({ ...site, repo: repo(site.repo) })) } }) };
+    });
+    const result = localFindingsPayloadSchema.safeParse({ ...identity, agent, findings });
+    if (!result.success)
+        throw new Error(RESULTS_TOO_LARGE_MESSAGE);
+    return result.data;
+}

package/dist/{main.js → cli/main.js}

@@ -2,39 +2,50 @@
 import { pathToFileURL } from "node:url";
 import { realpath } from "node:fs/promises";
 import { errorCode, errorText } from "./api.js";
+import { readEmailSignIn } from "../adapters/settings.js";
 import { commandContext } from "./context.js";
-import { check } from "./commands/check.js";
+import { analyze } from "./commands/analyze.js";
 import { finding } from "./commands/finding.js";
 import { balance } from "./commands/balance.js";
-import { login } from "./commands/login.js";
+import { login, parseLoginOptions } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { serveMcp } from "./mcp.js";
-const usage = "Usage: counterfact-labs check [path] [--yes] [--dry-run]\n       counterfact-labs finding <id>\n       counterfact-labs balance | login | logout | mcp\n";
+const usage = "Usage: counterfact-labs analyze [path]\n       counterfact-labs finding <id>\n       counterfact-labs balance | login | logout | mcp\n";
 export async function run(args, options = {}) {
     const write = options.write ?? (text => { process.stdout.write(text); });
+    const emailSignIn = options.emailSignIn ?? readEmailSignIn(options.env);
+    const commandOptions = { ...options, emailSignIn };
     try {
         const [command, ...rest] = args;
         if (["--help", "-h", "help"].includes(command) || !command) {
             write(usage);
             return 0;
         }
-        if (command === "check") {
-            const flags = rest.filter(arg => arg.startsWith("--"));
-            const paths = rest.filter(arg => !arg.startsWith("--"));
-            if (paths.length > 1 || flags.some(flag => !["--yes", "--dry-run"].includes(flag)))
+        if (command === "analyze") {
+            if (rest.length > 1 || rest.some(arg => arg.startsWith("-")))
                 throw new Error(usage.trimEnd());
-            return await check(paths[0] ?? ".", { yes: flags.includes("--yes"), dryRun: flags.includes("--dry-run") }, commandContext(options));
+            return await analyze(rest[0] ?? ".", {}, commandContext(commandOptions));
         }
         if (command === "finding" && rest.length === 1 && !rest[0].startsWith("-"))
-            return await finding(rest[0], commandContext(options));
+            return await finding(rest[0], commandContext(commandOptions));
+        if (command === "login" && emailSignIn) {
+            let parsed;
+            try {
+                parsed = parseLoginOptions(rest);
+            }
+            catch {
+                throw new Error(usage.trimEnd());
+            }
+            return await login(commandContext(commandOptions), parsed);
+        }
         if (rest.length)
             throw new Error(usage.trimEnd());
         if (command === "balance")
-            return await balance(commandContext(options));
+            return await balance(commandContext(commandOptions));
         if (command === "login")
-            return await login(commandContext(options));
+            return await login(commandContext(commandOptions));
         if (command === "logout")
-            return await logout(commandContext(options));
+            return await logout(commandContext(commandOptions));
         if (command === "mcp") {
             await serveMcp(process.stdin, process.stdout, options);
             return 0;

package/dist/{mcp.js → cli/mcp.js}

@@ -1,26 +1,29 @@
 import { createInterface } from "node:readline";
 import { once } from "node:events";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { resolveFolderPath } from "../adapters/folder-path.js";
+import { FINISH_FAILURE_MESSAGE, START_FAILURE_MESSAGE } from "../contract/cli-refusals.js";
 import { errorCode, errorText } from "./api.js";
 import { commandContext } from "./context.js";
-import { confirmPrepared, prepareCheck } from "./commands/check.js";
+import { analyze } from "./commands/analyze.js";
+import { CLI_VERSION } from "../contract/cli-version.js";
 import { finding } from "./commands/finding.js";
 import { balance } from "./commands/balance.js";
-import { checkToolAllowed } from "./claude-code-permission.js";
+import { ANALYZE_TOOL_NAME, analyzeToolAllowed } from "./claude-code-permission.js";
 import { signInStatus, startSignIn } from "./sign-in.js";
-const tools = [
+import { readEmailSignIn } from "../adapters/settings.js";
+import { emailSignInMessages } from "../contract/email-sign-in-messages.js";
+import { EMAIL_SIGN_IN_TERMS, normalizeSignInEmail, validSignInCode, startEmailSignIn, signInWithCode } from "./email-sign-in.js";
+import { resolveAgentFolder, resolveMcpAgentFolder } from "./agent-folder.js";
+import { suggestedEmail } from "./suggested-email.js";
+const legacyTools = [
     {
-        name: "check_agent",
-        description: "Preview the files and price of an agent check. Show the user the price and get their agreement "
-            + "before calling with confirm: true. A confirmation uses the most recent preview for that path in this session. "
-            + "Suggest a check after edits; wait for the user to ask for it. If the tool call is cancelled or times out, "
-            + "a confirmed check keeps running on the server and its result will be in the console's Checks page.",
-        inputSchema: { type: "object", properties: { path: { type: "string", description: "The agent folder on this computer." }, confirm: { type: "boolean", default: false } }, required: ["path"], additionalProperties: false },
+        name: ANALYZE_TOOL_NAME,
+        description: "Analyze the agent in a folder on this computer. Each call runs one analysis and charges the user's balance, so call it only when the user asks for an analysis. After edits, suggest an analysis and wait for the user to ask. Prices are listed on the top-up page and website. If the balance doesn't cover the analysis, show the returned message and top-up link.",
+        inputSchema: { type: "object", properties: { path: { type: "string", description: "The agent folder on this computer." } }, required: ["path"], additionalProperties: false },
     },
-    { name: "get_finding", description: "Get a finding's explanation, quoted lines and suggested fixes.", inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false } },
+    { name: "get_finding", description: "Get a finding's explanation, quoted lines, and suggested fixes.", inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false } },
     { name: "get_balance", description: "Get the balance and top-up link.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
-    { name: "sign_in_status", description: "Check whether this computer is signed in to Counterfact, and whether the user has allowed the check tool in Claude Code. With wait: true, first wait for a sign-in started by sign_in to finish.", inputSchema: { type: "object", properties: { wait: { type: "boolean" } }, additionalProperties: false } },
+    { name: "sign_in_status", description: "Check whether this computer is signed in to Counterfact, and whether the user has allowed the analysis tool in Claude Code. With wait: true, first wait for a sign-in started by sign_in to finish.", inputSchema: { type: "object", properties: { wait: { type: "boolean" } }, additionalProperties: false } },
     { name: "sign_in", description: "Open the Counterfact sign-in page in the user's browser. Then call sign_in_status with wait: true.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
 ];
 class ProtocolError extends Error {
@@ -32,9 +35,36 @@ class ProtocolError extends Error {
 }
 function object(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
 export async function serveMcp(input, output, options = {}) {
-    const { version } = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-    const previews = new Map();
     const cwd = options.cwd ?? process.cwd();
+    const guarded = (options.env ?? process.env).CF_MCP_PATH_GUARD !== "0";
+    const launch = guarded ? resolveFolderPath(cwd).catch(() => null) : Promise.resolve(cwd);
+    const lastAnalysis = new Map();
+    const emailSignIn = options.emailSignIn ?? readEmailSignIn(options.env);
+    const tools = emailSignIn ? [...legacyTools.slice(0, 3),
+        {
+            name: "sign_in_status",
+            description: "Check whether this computer is signed in to Counterfact and whether the user has allowed the analysis tool in Claude Code. Use path only to choose the agent folder for the local git email suggestion; otherwise use the launch folder. Analysis permission is always checked in the launch folder. A valid local git email is returned as suggestedEmail. Prefer the signed-in user's email already in your context; otherwise offer suggestedEmail. Ask the user to confirm an address before sending a code. With wait: true, wait only for browser sign-in to finish.",
+            inputSchema: { type: "object", properties: {
+                    wait: { type: "boolean" },
+                    path: { type: "string", description: "The chosen agent folder for the local git email suggestion. Defaults to the launch folder; does not change the analysis permission check." },
+                }, additionalProperties: false },
+        },
+        {
+            name: "sign_in",
+            description: `With email, send a Counterfact sign-in code only after the user confirms that address. Before calling, show: ${EMAIL_SIGN_IN_TERMS} Then ask the user for the code from their email and call sign_in_with_code. Without email, open the Counterfact sign-in page in the user's browser, show the returned link and code, then call sign_in_status with wait: true.`,
+            inputSchema: { type: "object", properties: {
+                    email: { type: "string", description: "The email address confirmed by the user." },
+                }, additionalProperties: false },
+        },
+        {
+            name: "sign_in_with_code",
+            description: "Complete Counterfact email sign-in with the confirmed email address and the code supplied by the user. Save the sign-in on this computer. Never repeat the code in messages, logs, or reports. Do not request another code automatically.",
+            inputSchema: { type: "object", properties: {
+                    email: { type: "string", description: "The email address confirmed by the user." },
+                    code: { type: "string", description: "The sign-in code supplied by the user from their email." },
+                }, required: ["email", "code"], additionalProperties: false },
+        },
+    ] : legacyTools;
     let pendingSignIn;
     const requests = new Map();
     let queue = Promise.resolve();
@@ -46,21 +76,35 @@ export async function serveMcp(input, output, options = {}) {
         if (!object(args))
             throw new ProtocolError(-32602, "Tool arguments must be an object.");
         const name = params.name;
-        const allowed = name === "check_agent" ? ["path", "confirm"] : name === "get_finding" ? ["id"] : name === "sign_in_status" ? ["wait"] : [];
+        const allowed = name === ANALYZE_TOOL_NAME ? ["path"] : name === "get_finding" ? ["id"]
+            : name === "sign_in_status" ? (emailSignIn ? ["wait", "path"] : ["wait"])
+                : emailSignIn && name === "sign_in" ? ["email"] : emailSignIn && name === "sign_in_with_code" ? ["email", "code"] : [];
         if (!tools.some(tool => tool.name === name) || Object.keys(args).some(key => !allowed.includes(key)))
             throw new ProtocolError(-32602, "Unknown tool or argument.");
-        if (name === "check_agent" && (typeof args.path !== "string" || !args.path.trim() || (args.confirm !== undefined && typeof args.confirm !== "boolean")))
-            throw new ProtocolError(-32602, "Provide a path and an optional boolean confirmation.");
+        if (name === ANALYZE_TOOL_NAME && (typeof args.path !== "string" || !args.path.trim()))
+            throw new ProtocolError(-32602, "Provide a path.");
         if (name === "get_finding" && (typeof args.id !== "string" || !args.id.trim()))
             throw new ProtocolError(-32602, "Provide a finding id.");
         if (name === "sign_in_status" && args.wait !== undefined && typeof args.wait !== "boolean")
             throw new ProtocolError(-32602, "Provide an optional boolean wait.");
+        if (name === "sign_in_status" && "path" in args && (typeof args.path !== "string" || !args.path.trim()))
+            throw new ProtocolError(-32602, "Provide a path.");
+        const emailFlow = name === "sign_in_with_code" || (name === "sign_in" && "email" in args);
+        const email = emailFlow ? normalizeSignInEmail(args.email) : undefined;
+        if (emailFlow && !email)
+            throw new ProtocolError(-32602, emailSignInMessages.invalid_email);
+        if (name === "sign_in_with_code" && !validSignInCode(args.code))
+            throw new ProtocolError(-32602, emailSignInMessages.invalid_code);
         let text = "", exitCode = 0;
         let findingIds;
         let url;
         let signIn;
         try {
-            const ctx = commandContext({ ...options, signal, write: chunk => {
+            const ctx = commandContext({ ...options, emailSignIn, signal, onCheckComplete: result => {
+                    findingIds = result.findingIds ?? [];
+                    url = result.url;
+                    options.onCheckComplete?.(result);
+                }, write: chunk => {
                     // Progress is transient terminal text; only the final lines belong in a tool response.
                     if (!chunk.startsWith("\r"))
                         text += chunk;
@@ -71,7 +115,7 @@ export async function serveMcp(input, output, options = {}) {
                 await balance(ctx);
             else if (name === "sign_in_status") {
                 const pending = pendingSignIn;
-                const allowed = await checkToolAllowed(ctx.homeDir, cwd);
+                const allowed = await analyzeToolAllowed(ctx.homeDir, cwd);
                 if (args.wait === true && pending) {
                     const cancel = () => pending.controller.abort();
                     signal.addEventListener("abort", cancel, { once: true });
@@ -84,8 +128,27 @@ export async function serveMcp(input, output, options = {}) {
                         signal.removeEventListener("abort", cancel);
                     }
                 }
-                signIn = { ...await signInStatus(ctx), checkToolAllowed: allowed };
+                signIn = { ...await signInStatus(ctx), analyzeToolAllowed: allowed };
                 text = signIn.signedIn ? "Signed in." : "Not signed in.";
+                if (emailSignIn) {
+                    const suggestion = await suggestedEmail(resolveAgentFolder(args.path ?? ".", cwd), ctx.readEmail);
+                    if (suggestion)
+                        signIn.suggestedEmail = suggestion;
+                }
+            }
+            else if (emailFlow) {
+                if (pendingSignIn)
+                    throw new Error(emailSignInMessages.browser_sign_in_pending);
+                if (name === "sign_in") {
+                    const start = await startEmailSignIn(ctx, email);
+                    signIn = { email: email, expiresIn: start.expiresIn };
+                    text = `We sent a sign-in code to ${email}. Ask the user for the code from their email, then call sign_in_with_code with the same email and their code. Do not repeat the code.`;
+                }
+                else {
+                    await signInWithCode(ctx, email, args.code);
+                    signIn = { signedIn: true };
+                    text = "Signed in.";
+                }
             }
             else if (name === "sign_in") {
                 if ((await signInStatus(ctx)).signedIn)
@@ -99,7 +162,7 @@ export async function serveMcp(input, output, options = {}) {
                         signal.addEventListener("abort", cancel, { once: true });
                         try {
                             signal.throwIfAborted();
-                            const flow = await startSignIn(commandContext({ ...options, homeDir: ctx.homeDir, baseUrl: ctx.api.baseUrl, signal: controller.signal }));
+                            const flow = await startSignIn(commandContext({ ...options, emailSignIn, homeDir: ctx.homeDir, baseUrl: ctx.api.baseUrl, signal: controller.signal }));
                             pending = { flow, controller, opened: false };
                             pendingSignIn = pending;
                             const current = pending;
@@ -119,22 +182,26 @@ export async function serveMcp(input, output, options = {}) {
                 }
             }
             else {
-                const path = resolve(args.path);
-                if (args.confirm === true) {
-                    const prepared = previews.get(path);
-                    previews.delete(path);
-                    if (!prepared)
-                        throw new Error("Get a preview first. Show the user the price and get their agreement before confirming.");
-                    url = prepared.url;
-                    const result = await confirmPrepared(prepared, ctx);
-                    findingIds = result.findingIds;
-                    url = result.taste.url;
+                const launchFolder = await launch;
+                if (guarded && !launchFolder)
+                    throw new Error(START_FAILURE_MESSAGE);
+                const folder = guarded ? await resolveMcpAgentFolder(args.path, launchFolder, ctx.homeDir) : resolveAgentFolder(args.path, cwd);
+                const last = lastAnalysis.get(folder);
+                if (guarded && last !== undefined && ctx.now() - last < 10 * 60 * 1000) {
+                    throw new Error(FINISH_FAILURE_MESSAGE);
                 }
-                else {
-                    previews.delete(path);
-                    const prepared = await prepareCheck(args.path, ctx);
-                    previews.set(path, prepared);
-                    url = prepared.url;
+                let started = false;
+                try {
+                    exitCode = await analyze(folder, {}, { ...ctx, onCheckStart: () => {
+                            started = true;
+                            if (guarded)
+                                lastAnalysis.set(folder, ctx.now());
+                            ctx.onCheckStart?.();
+                        } });
+                }
+                finally {
+                    if (guarded && started)
+                        lastAnalysis.set(folder, ctx.now());
                 }
             }
         }
@@ -143,7 +210,7 @@ export async function serveMcp(input, output, options = {}) {
             exitCode = errorCode(error);
         }
         // Some clients (Claude Code among them) give the model only the structured result when one is present, so it
-        // repeats the text: without it the model sees no files, price or results.
+        // repeats the text: without it the model cannot read the result.
         return { content: [{ type: "text", text }], isError: exitCode !== 0,
             structuredContent: { text, exitCode, ...(findingIds ? { findingIds } : {}), ...(url ? { url } : {}), ...signIn } };
     }
@@ -156,7 +223,7 @@ export async function serveMcp(input, output, options = {}) {
             if (message.method === "initialize") {
                 const requested = object(message.params) ? message.params.protocolVersion : undefined;
                 result = { protocolVersion: ["2024-11-05", "2025-03-26", "2025-06-18"].includes(requested) ? requested : "2025-06-18",
-                    capabilities: { tools: {} }, serverInfo: { name: "counterfact-labs", version } };
+                    capabilities: { tools: {} }, serverInfo: { name: "counterfact-labs", version: CLI_VERSION } };
             }
             else if (message.method === "ping")
                 result = {};
@@ -172,6 +239,8 @@ export async function serveMcp(input, output, options = {}) {
             reply = errorReply(id, error);
         }
         // The caller stopped waiting; a late result must not look like a completed call.
+        // The output is an MCP stdio Writable carrying JSON-RPC, not an HTML HTTP response.
+        // nosemgrep: javascript.express.security.audit.xss.direct-response-write.direct-response-write
         if (!signal.aborted && !output.write(JSON.stringify(reply) + "\n"))
             await once(output, "drain");
     }
@@ -202,7 +271,7 @@ export async function serveMcp(input, output, options = {}) {
             id = message.id;
             const controller = new AbortController();
             requests.set(id, controller);
-            // Keep preview and confirm in order while still reading cancellation notifications.
+            // Keep tool requests in order while still reading cancellation notifications.
             const request = message;
             queue = queue.then(() => respond(request, id, controller.signal)).finally(() => { requests.delete(id); });
             continue;

package/dist/cli/output.js

@@ -0,0 +1,10 @@
+export function money(micro) {
+    const cents = Math.round(micro / 10_000);
+    const whole = Math.trunc(cents / 100);
+    const fraction = Math.abs(cents % 100);
+    return `${cents < 0 ? "-" : ""}$${Math.abs(whole)}${fraction ? `.${String(fraction).padStart(2, "0")}` : ""}`;
+}
+export function tasteText(taste, findingIds) {
+    return [taste.headline, ...taste.lines.map(line => `  ${line}`),
+        ...(findingIds.length ? [`Finding ids: ${findingIds.join(", ")}`] : []), `Full results: ${taste.url}`, ""].join("\n");
+}