diff --git a/infra/console.ts b/infra/console.ts index 370bde42f86..84e64d05a79 100644 --- a/infra/console.ts +++ b/infra/console.ts @@ -8,6 +8,8 @@ new sst.cloudflare.Bucket("ZenDataNew") const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID") const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY") const ENTERPRISE_SALES_INBOX_EMAIL = new sst.Secret("ENTERPRISE_SALES_INBOX_EMAIL") +// OpenCode API key for Jev spam scoring of enterprise form submissions. +const ENTERPRISE_SPAM_API_KEY = new sst.Secret("ENTERPRISE_SPAM_API_KEY") // hCaptcha guards the enterprise form; the site key is public and baked into the client bundle. const HCAPTCHA_SITE_KEY = new sst.Secret("HCAPTCHA_SITE_KEY") const HCAPTCHA_SECRET_KEY = new sst.Secret("HCAPTCHA_SECRET_KEY") @@ -24,6 +26,7 @@ new sst.cloudflare.x.SolidStart("Console", { AWS_SES_ACCESS_KEY_ID, AWS_SES_SECRET_ACCESS_KEY, ENTERPRISE_SALES_INBOX_EMAIL, + ENTERPRISE_SPAM_API_KEY, HCAPTCHA_SECRET_KEY, SALESFORCE_CLIENT_ID, SALESFORCE_CLIENT_SECRET, diff --git a/packages/console/app/src/lib/enterprise-spam.test.ts b/packages/console/app/src/lib/enterprise-spam.test.ts new file mode 100644 index 00000000000..a5972864621 --- /dev/null +++ b/packages/console/app/src/lib/enterprise-spam.test.ts @@ -0,0 +1,107 @@ +import { afterEach, expect, mock, spyOn, test } from "bun:test" +import { enterpriseSpamProbability, ENTERPRISE_SPAM_MODEL, ENTERPRISE_SPAM_URL } from "./enterprise-spam" +import { handleEnterpriseRequest } from "./enterprise" + +const submission = { + name: "Fake Visitor", + role: "Engineering lead", + company: "Example Test Company", + email: "fake-visitor@example.test", + message: "We need SSO for 200 developers.", +} + +afterEach(() => mock.restore()) + +const score = (probability: unknown) => + Response.json({ model: ENTERPRISE_SPAM_MODEL, answers: { spam: { type: "noul", noul: probability } } }) + +test("scores a submission through the System One gateway", async () => { + const requests: Request[] = [] + // The form handler passes the whole submission, phone included; the classifier must not receive it. + const withPhone = { ...submission, phone: "+1 555 0100" } + const probability = await enterpriseSpamProbability(withPhone, { + apiKey: "test-key", + fetch: async (request) => { + requests.push(request) + return score(0.97) + }, + }) + + expect(probability).toBe(0.97) + expect(requests).toHaveLength(1) + expect(requests[0].url).toBe(ENTERPRISE_SPAM_URL) + expect(requests[0].headers.get("authorization")).toBe("Bearer test-key") + const body = await requests[0].json() + expect(body.model).toBe(ENTERPRISE_SPAM_MODEL) + expect(body.state.submission).toMatchObject({ email: submission.email, message: submission.message }) + expect(body.state.submission).not.toHaveProperty("phone") + expect(body.questions.spam.type).toBe("noul") +}) + +test("returns no score when the gateway fails, times out, or answers without a probability", async () => { + const options = { apiKey: "test-key" } + const failures = [ + async () => new Response("nope", { status: 401 }), + async () => { + throw new Error("network") + }, + async () => score("high"), + async () => score(1.5), + async () => Response.json({ answers: {} }), + (request: Request) => + new Promise((_, reject) => + request.signal.addEventListener("abort", () => reject(request.signal.reason)), + ), + ] + for (const fetch of failures) { + expect(await enterpriseSpamProbability(submission, { ...options, timeoutMs: 20, fetch })).toBeUndefined() + } +}) + +const submit = async (fetch: (request: Request) => Promise) => { + const leads: Record[] = [] + const response = await handleEnterpriseRequest( + new Request("http://localhost/api/enterprise", { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ ...submission, alias: "", captcha: "token" }), + }), + { + captcha: { secret: "test-secret", fetch: async () => Response.json({ success: true }) }, + spam: { apiKey: "test-key", fetch }, + salesforceSubmit: async (payload) => { + leads.push(payload) + return true + }, + notifications: false, + }, + ) + return { status: response.status, body: await response.json(), leads } +} + +test("confident spam gets the normal success response, never reaches Salesforce, and is logged", async () => { + const warn = spyOn(console, "warn").mockImplementation(() => {}) + const result = await submit(async () => score(0.95)) + expect(result.status).toBe(200) + expect(result.body).toMatchObject({ success: true }) + expect(result.leads).toHaveLength(0) + expect(warn).toHaveBeenCalledWith("Enterprise inquiry dropped as spam", { + email: submission.email, + probability: 0.95, + }) +}) + +test("uncertain, missing, or failed scores still create the lead", async () => { + spyOn(console, "error").mockImplementation(() => {}) + for (const fetch of [ + async () => score(0.6), + async () => Response.json({ answers: {} }), + async () => { + throw new Error("classifier down") + }, + ]) { + const result = await submit(fetch) + expect(result.status).toBe(200) + expect(result.leads).toHaveLength(1) + } +}) diff --git a/packages/console/app/src/lib/enterprise-spam.ts b/packages/console/app/src/lib/enterprise-spam.ts new file mode 100644 index 00000000000..5d4fc25f4c0 --- /dev/null +++ b/packages/console/app/src/lib/enterprise-spam.ts @@ -0,0 +1,69 @@ +import { Resource } from "@opencode/console-resource" + +export const ENTERPRISE_SPAM_URL = "https://opencode.ai/inference/systemone/v1/systemone" +export const ENTERPRISE_SPAM_MODEL = "jev-1.13" +// Drop only submissions Jev is confident about; anything less reaches sales as before. +export const ENTERPRISE_SPAM_THRESHOLD = 0.9 +const TIMEOUT_MS = 2000 + +const question = { + type: "noul", + instructions: + "Is this OpenCode enterprise sales form submission spam, abuse, or an attack rather than a genuine inquiry from someone interested in OpenCode?", + criteria: { + true: "Code, HTML, scripts, SQL, template or prompt-injection payloads, or other attack strings in any field; gibberish or random characters; advertising, SEO, link building, crypto, adult, or gambling content; someone selling their own product or services to OpenCode; or mass-mailed text unrelated to OpenCode.", + false: + "A real person asking about OpenCode for their company or team, including pricing, seats, security, SSO, deployment, models, procurement, support, or a partnership. Short, informal, misspelled, non-English, or vague messages are still genuine when they appear to come from a person interested in OpenCode.", + }, +} as const + +// Scores a submission with Jev through the OpenCode System One gateway. +// Returns undefined when scoring is unavailable so the caller can fail open. +export async function enterpriseSpamProbability( + input: { name: string; role: string; company?: string; email: string; message: string }, + options: { + fetch?: (request: Request) => Promise + apiKey?: string + timeoutMs?: number + } = {}, +): Promise { + try { + const response = await (options.fetch ?? fetch)( + new Request(ENTERPRISE_SPAM_URL, { + method: "POST", + headers: { + Authorization: `Bearer ${options.apiKey ?? Resource.ENTERPRISE_SPAM_API_KEY.value}`, + "Content-Type": "application/json", + }, + body: JSON.stringify({ + model: ENTERPRISE_SPAM_MODEL, + state: { + submission: { + name: input.name, + role: input.role, + company: input.company ?? "", + email: input.email, + message: input.message, + }, + }, + questions: { spam: question }, + }), + signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS), + }), + ) + if (!response.ok) { + console.error("Enterprise spam scoring failed:", response.status) + return undefined + } + const data = (await response.json()) as { answers?: { spam?: { type?: string; noul?: unknown } } } + const probability = data.answers?.spam?.noul + if (typeof probability !== "number" || !Number.isFinite(probability) || probability < 0 || probability > 1) { + console.error("Enterprise spam scoring returned no probability") + return undefined + } + return probability + } catch (error) { + console.error("Enterprise spam scoring unavailable:", error instanceof Error ? error.name : "unknown") + return undefined + } +} diff --git a/packages/console/app/src/lib/enterprise.ts b/packages/console/app/src/lib/enterprise.ts index 9720bd2d156..5088e6dde78 100644 --- a/packages/console/app/src/lib/enterprise.ts +++ b/packages/console/app/src/lib/enterprise.ts @@ -4,6 +4,7 @@ import { i18n } from "~/i18n" import { localeFromRequest } from "~/lib/language" import { createLead } from "~/lib/salesforce" import { inferenceSpendOptions } from "~/lib/inference-spend" +import { ENTERPRISE_SPAM_THRESHOLD, enterpriseSpamProbability } from "~/lib/enterprise-spam" import { verifyHcaptcha } from "~/lib/hcaptcha" interface EnterpriseFormData { @@ -96,6 +97,7 @@ export async function handleEnterpriseRequest( options: { salesforceSubmit?: (payload: Record) => Promise notifications?: boolean + spam?: Parameters[1] captcha?: Parameters[1] } = {}, ) { @@ -134,6 +136,15 @@ export async function handleEnterpriseRequest( return Response.json({ error: dict["enterprise.form.error.captcha"] }, { status: 400 }) } + // Fail open: a missing score never blocks a lead. Confident spam gets the same + // response as the honeypot and never reaches Salesforce, email, or EmailOctopus. + const spam = await enterpriseSpamProbability(body, options.spam) + if (spam !== undefined) console.info("Enterprise inquiry spam score", { probability: spam }) + if (spam !== undefined && spam >= ENTERPRISE_SPAM_THRESHOLD) { + console.warn("Enterprise inquiry dropped as spam", { email: body.email, probability: spam }) + return Response.json({ success: true, message: dict["enterprise.form.success.submitted"] }, { status: 200 }) + } + const emailContent = enterpriseEmailContent(body, inferenceSpend?.salesforceValue) const [lead, mail, octopus] = await Promise.all([ diff --git a/packages/console/app/src/lib/hcaptcha.test.ts b/packages/console/app/src/lib/hcaptcha.test.ts index 4e24e356c37..ab95f0a47c3 100644 --- a/packages/console/app/src/lib/hcaptcha.test.ts +++ b/packages/console/app/src/lib/hcaptcha.test.ts @@ -66,6 +66,7 @@ const submit = async (captcha: string | undefined, verify: () => Promise new Response(null, { status: 503 }) }, salesforceSubmit: async (payload) => { leads.push(payload) return true diff --git a/packages/console/app/src/routes/api/enterprise.ts b/packages/console/app/src/routes/api/enterprise.ts index c2048552fcd..6b488c43004 100644 --- a/packages/console/app/src/routes/api/enterprise.ts +++ b/packages/console/app/src/routes/api/enterprise.ts @@ -6,7 +6,7 @@ import { localeFromRequest } from "~/lib/language" // SolidStart keeps only the method export from API routes, so the handler lives in lib. export async function POST(event: APIEvent) { - // Outside production, accept submissions without reaching spam scoring, Salesforce, email, or EmailOctopus. + // Outside production, accept submissions without reaching hCaptcha, spam scoring, Salesforce, email, or EmailOctopus. if (import.meta.env.DEV || Resource.App.stage !== "production") return Response.json({ success: true,