Skip to content

Open-source SEO, GEO, and marketing skills for AI agents.

feat(onboarding): Google Ads account picker for multi-account bearers

Yuting Zhongfa0a67b78582
diff --git a/src/app/api/onboarding/stream/route.ts b/src/app/api/onboarding/stream/route.ts
index e646f8b5..dedf9961 100644
--- a/src/app/api/onboarding/stream/route.ts
+++ b/src/app/api/onboarding/stream/route.ts
@@ -1,6 +1,7 @@
import { NextRequest } from "next/server";
import { getActiveProject } from "@/server/active-project";
+import { getProject } from "@/server/db/projects";
import { runAudit } from "@/server/onboarding/audit";
import { awaitProvisioning } from "@/server/onboarding/provisioning-state";
import type { StreamEvent } from "@/lib/onboarding/events";
@@ -81,8 +82,14 @@ export async function GET(req: NextRequest) {
}
send({ type: "provision:ready" });
- // Phase 2: stream audit events.
- for await (const event of runAudit(slug, abortAudit.signal)) {
+ // Phase 2: stream audit events. Pass the user's selected Google Ads
+ // account ID so MCP runScript targets the right customer; null when
+ // the user hasn't picked yet (single-account bearer case).
+ const project = getProject(slug);
+ const accountId = project?.google_ads_account_id ?? null;
+ for await (const event of runAudit(slug, abortAudit.signal, {
+ accountId,
+ })) {
if (closed) break;
send(event);
if (event.type === "audit:finding") {
diff --git a/src/components/onboarding-flow.tsx b/src/components/onboarding-flow.tsx
index fb5f6533..037fa4f0 100644
--- a/src/components/onboarding-flow.tsx
+++ b/src/components/onboarding-flow.tsx
@@ -22,6 +22,11 @@ import { Label } from "@/components/ui/label";
import { cn } from "@/lib/utils";
import { startMcpConnect } from "@/server/actions/mcp";
import { createProjectForOnboardingAction } from "@/server/actions/projects";
+import {
+ listGoogleAdsAccounts,
+ setOnboardingAccountAction,
+ type GoogleAdsAccount,
+} from "@/server/onboarding/accounts";
import type {
AuditSummary,
Finding,
@@ -29,7 +34,7 @@ import type {
StreamEvent,
} from "@/lib/onboarding/events";
-type Step = "name" | "connect" | "audit";
+type Step = "name" | "connect" | "account" | "audit";
export function OnboardingFlow() {
const router = useRouter();
@@ -37,7 +42,9 @@ export function OnboardingFlow() {
const stepParam = params.get("step");
const slug = params.get("slug") ?? null;
const step: Step =
- stepParam === "connect" || stepParam === "audit"
+ stepParam === "connect" ||
+ stepParam === "account" ||
+ stepParam === "audit"
? stepParam
: "name";
@@ -58,10 +65,10 @@ export function OnboardingFlow() {
/>
)}
{step === "connect" && slug && <ConnectStep slug={slug} />}
+ {step === "account" && slug && <AccountStep slug={slug} />}
{step === "audit" && slug && <AuditStep slug={slug} />}
- {(step === "connect" || step === "audit") && !slug && (
- <MissingSlug />
- )}
+ {(step === "connect" || step === "account" || step === "audit") &&
+ !slug && <MissingSlug />}
</main>
</div>
);
@@ -143,7 +150,7 @@ function ConnectStep({ slug }: { slug: string }) {
try {
const result = await startMcpConnect({
mcp_key: "notfair-googleads",
- return_to: `/onboarding?step=audit&slug=${encodeURIComponent(slug)}`,
+ return_to: `/onboarding?step=account&slug=${encodeURIComponent(slug)}`,
});
if (!result.ok) {
toast.error(result.error);
@@ -207,7 +214,226 @@ function ConnectStep({ slug }: { slug: string }) {
);
}
-// ── Step 3: Audit (terminal) ───────────────────────────────────────
+// ── Step 3: Pick Google Ads account (auto-skipped if only 1) ───────
+
+type AccountListState =
+ | { phase: "loading" }
+ | { phase: "loaded"; accounts: GoogleAdsAccount[]; default_account_id: string | null }
+ | { phase: "error"; message: string };
+
+function AccountStep({ slug }: { slug: string }) {
+ const router = useRouter();
+ const [state, setState] = useState<AccountListState>({ phase: "loading" });
+ const [pickingId, setPickingId] = useState<string | null>(null);
+ // Guard against StrictMode double-mount auto-selecting twice.
+ const autoSelectedRef = useRef(false);
+
+ useEffect(() => {
+ let cancelled = false;
+ (async () => {
+ const result = await listGoogleAdsAccounts(slug);
+ if (cancelled) return;
+ if (!result.ok) {
+ setState({
+ phase: "error",
+ message: result.error,
+ });
+ return;
+ }
+ setState({
+ phase: "loaded",
+ accounts: result.accounts,
+ default_account_id: result.default_account_id,
+ });
+ })();
+ return () => {
+ cancelled = true;
+ };
+ }, [slug]);
+
+ // Auto-skip when there's exactly one account — no point making the user
+ // pick from a list of one. We still call the server action so the project
+ // row gets the id persisted, then forward to the audit step.
+ useEffect(() => {
+ if (state.phase !== "loaded") return;
+ if (state.accounts.length !== 1) return;
+ if (autoSelectedRef.current) return;
+ autoSelectedRef.current = true;
+ (async () => {
+ const only = state.accounts[0]!;
+ const result = await setOnboardingAccountAction(slug, only.id);
+ if (!result.ok) {
+ toast.error(result.error);
+ setState({ phase: "error", message: result.error });
+ return;
+ }
+ router.replace(`/onboarding?step=audit&slug=${encodeURIComponent(slug)}`);
+ })();
+ }, [state, slug, router]);
+
+ async function onPick(account: GoogleAdsAccount) {
+ setPickingId(account.id);
+ try {
+ const result = await setOnboardingAccountAction(slug, account.id);
+ if (!result.ok) {
+ toast.error(result.error);
+ setPickingId(null);
+ return;
+ }
+ router.replace(`/onboarding?step=audit&slug=${encodeURIComponent(slug)}`);
+ } catch (err) {
+ toast.error(err instanceof Error ? err.message : String(err));
+ setPickingId(null);
+ }
+ }
+
+ if (state.phase === "loading") {
+ return (
+ <Card>
+ <CardContent className="space-y-2 pt-6 pb-6">
+ <div className="flex items-center gap-3 text-sm">
+ <Loader2 className="size-4 animate-spin text-muted-foreground" aria-hidden />
+ <span className="font-medium">Loading your Google Ads accounts&hellip;</span>
+ </div>
+ </CardContent>
+ </Card>
+ );
+ }
+
+ if (state.phase === "error") {
+ return (
+ <Card role="alert">
+ <CardContent className="space-y-3 pt-6 pb-6">
+ <div className="flex items-center gap-2">
+ <AlertCircle className="size-4 text-amber-600" aria-hidden />
+ <span className="font-medium text-sm">
+ Couldn&rsquo;t load your Google Ads accounts.
+ </span>
+ </div>
+ <p className="text-xs text-muted-foreground">{state.message}</p>
+ <div className="flex gap-2">
+ <Button asChild>
+ <Link href="/onboarding">Retry from start</Link>
+ </Button>
+ <Button variant="outline" asChild>
+ <Link href="/agents/cmo/chat">Skip to chat</Link>
+ </Button>
+ </div>
+ </CardContent>
+ </Card>
+ );
+ }
+
+ if (state.accounts.length === 0) {
+ return (
+ <Card role="alert">
+ <CardContent className="space-y-3 pt-6 pb-6">
+ <div className="flex items-center gap-2">
+ <AlertCircle className="size-4 text-amber-600" aria-hidden />
+ <span className="font-medium text-sm">
+ No Google Ads accounts found on this connection.
+ </span>
+ </div>
+ <p className="text-xs text-muted-foreground">
+ The connected user has no Google Ads customer accounts. Connect a
+ different account or skip and chat with your CMO.
+ </p>
+ <div className="flex gap-2">
+ <Button asChild>
+ <Link href={`/onboarding?step=connect&slug=${encodeURIComponent(slug)}`}>
+ Reconnect
+ </Link>
+ </Button>
+ <Button variant="outline" asChild>
+ <Link href="/agents/cmo/chat">Skip to chat</Link>
+ </Button>
+ </div>
+ </CardContent>
+ </Card>
+ );
+ }
+
+ // length === 1 → auto-selecting via effect above; render the same loading
+ // card so there's no flash of the picker UI.
+ if (state.accounts.length === 1) {
+ return (
+ <Card>
+ <CardContent className="space-y-2 pt-6 pb-6">
+ <div className="flex items-center gap-3 text-sm">
+ <Loader2 className="size-4 animate-spin text-muted-foreground" aria-hidden />
+ <span className="font-medium">
+ Using your only Google Ads account&hellip;
+ </span>
+ </div>
+ </CardContent>
+ </Card>
+ );
+ }
+
+ // length > 1 → picker.
+ return (
+ <>
+ <header className="space-y-2">
+ <h1 className="text-3xl font-semibold tracking-tight text-foreground">
+ Which Google Ads account?
+ </h1>
+ <p className="text-sm text-muted-foreground">
+ Your connection has {state.accounts.length} accounts. Pick the one
+ you want me to audit for this project. You can switch later in
+ Settings.
+ </p>
+ </header>
+
+ <ul className="space-y-2 list-none p-0">
+ {state.accounts.map((account) => {
+ const isDefault = account.id === state.default_account_id;
+ const isPicking = pickingId === account.id;
+ const isOtherPicking = pickingId !== null && !isPicking;
+ return (
+ <li key={account.id}>
+ <button
+ type="button"
+ onClick={() => onPick(account)}
+ disabled={pickingId !== null}
+ aria-label={`Audit ${account.name} (${account.id})`}
+ className={cn(
+ "block w-full rounded-md border bg-card p-4 text-left transition-colors hover:bg-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-foreground/30 disabled:cursor-not-allowed",
+ isOtherPicking && "opacity-50",
+ )}
+ >
+ <div className="flex items-center justify-between gap-3">
+ <div className="min-w-0 flex-1">
+ <div className="flex items-center gap-2">
+ <span className="font-medium text-sm">{account.name}</span>
+ {isDefault && (
+ <span className="rounded bg-muted px-1.5 py-0.5 text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
+ default
+ </span>
+ )}
+ </div>
+ <p className="text-xs text-muted-foreground tabular-nums">
+ Customer ID {account.id}
+ </p>
+ </div>
+ {isPicking ? (
+ <Loader2
+ className="size-4 animate-spin text-muted-foreground"
+ aria-hidden
+ />
+ ) : (
+ <ChevronRight className="size-4 text-muted-foreground" aria-hidden />
+ )}
+ </div>
+ </button>
+ </li>
+ );
+ })}
+ </ul>
+ </>
+ );
+}
+
+// ── Step 4: Audit (terminal) ───────────────────────────────────────
type AuditState =
| { phase: "provisioning" }
diff --git a/src/server/db/migrations.ts b/src/server/db/migrations.ts
index 088c49ae..f5bd96e6 100644
--- a/src/server/db/migrations.ts
+++ b/src/server/db/migrations.ts
@@ -4,7 +4,7 @@
//
// To add a migration:
// 1. Write src/server/db/migrations/00N_<name>.sql
-// 2. Append an entry below with the SAME contents
+// 2. Append an entry below with the SAME contents (order = apply order)
// 3. CI lint (TODO) keeps the two in sync
export type Migration = {
@@ -117,6 +117,16 @@ CREATE TABLE IF NOT EXISTS sequence_runs (
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
+`,
+ },
+ {
+ name: "002_google_ads_account.sql",
+ sql: `
+-- Per-project Google Ads account selection. Bearers from notfair.co's MCP
+-- can grant access to multiple customer accounts; onboarding asks the user
+-- to pick one and persists it here so the audit + later automation always
+-- target the right account.
+ALTER TABLE projects ADD COLUMN google_ads_account_id TEXT;
`,
},
];
diff --git a/src/server/db/migrations/002_google_ads_account.sql b/src/server/db/migrations/002_google_ads_account.sql
new file mode 100644
index 00000000..928537d2
--- /dev/null
+++ b/src/server/db/migrations/002_google_ads_account.sql
@@ -0,0 +1,5 @@
+-- Per-project Google Ads account selection. A bearer from notfair.co's MCP
+-- can grant access to multiple customer accounts; the onboarding flow asks
+-- the user to pick one and persists it here so the audit + later automation
+-- always target the right account.
+ALTER TABLE projects ADD COLUMN google_ads_account_id TEXT;
diff --git a/src/server/db/projects.ts b/src/server/db/projects.ts
index a1d10d2a..2542d137 100644
--- a/src/server/db/projects.ts
+++ b/src/server/db/projects.ts
@@ -41,15 +41,35 @@ export function createProject(input: CreateProjectInput): CreateProjectResult {
display_name: input.display_name.trim(),
created_at: new Date().toISOString(),
archived_at: null,
+ google_ads_account_id: null,
};
db.prepare(
- "INSERT INTO projects (id, slug, display_name, created_at, archived_at) VALUES (?, ?, ?, ?, NULL)",
+ "INSERT INTO projects (id, slug, display_name, created_at, archived_at, google_ads_account_id) VALUES (?, ?, ?, ?, NULL, NULL)",
).run(project.id, project.slug, project.display_name, project.created_at);
return { ok: true, project };
}
+/**
+ * Persist the chosen Google Ads customer ID for a project. Returns null when
+ * the project doesn't exist or is archived. Idempotent — re-setting to the
+ * same value is a no-op write.
+ */
+export function setProjectGoogleAdsAccount(
+ slug: string,
+ account_id: string | null,
+): Project | null {
+ const db = getDb();
+ const existing = db.prepare("SELECT 1 FROM projects WHERE slug = ?").get(slug);
+ if (!existing) return null;
+ db.prepare("UPDATE projects SET google_ads_account_id = ? WHERE slug = ?").run(
+ account_id,
+ slug,
+ );
+ return getProject(slug);
+}
+
export function renameProject(slug: string, display_name: string): Project | null {
const db = getDb();
const trimmed = display_name.trim();
diff --git a/src/server/onboarding/accounts.test.ts b/src/server/onboarding/accounts.test.ts
new file mode 100644
index 00000000..d13d5a2e
--- /dev/null
+++ b/src/server/onboarding/accounts.test.ts
@@ -0,0 +1,197 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── Mocks ──────────────────────────────────────────────────────────
+
+const getMcpConfigMock = vi.fn();
+const mcpRpcMock = vi.fn();
+vi.mock("@/server/mcp/rpc", () => ({
+ getMcpConfig: (...args: unknown[]) => getMcpConfigMock(...args),
+ mcpRpc: (...args: unknown[]) => mcpRpcMock(...args),
+}));
+
+const getProjectMock = vi.fn();
+const setProjectGoogleAdsAccountMock = vi.fn();
+vi.mock("@/server/db/projects", () => ({
+ getProject: (...args: unknown[]) => getProjectMock(...args),
+ setProjectGoogleAdsAccount: (...args: unknown[]) =>
+ setProjectGoogleAdsAccountMock(...args),
+}));
+
+vi.mock("next/cache", () => ({
+ revalidatePath: vi.fn(),
+}));
+
+import {
+ listGoogleAdsAccounts,
+ setOnboardingAccountAction,
+} from "./accounts";
+
+// ── Fixtures ───────────────────────────────────────────────────────
+
+const ACCOUNTS_PAYLOAD = {
+ accounts: [
+ { id: "7384288909", name: "IOW" },
+ { id: "7521406707", name: "PawsVIP" },
+ { id: "1301265570", name: "InOtherWord.ai" },
+ { id: "7073485715", name: "BulkGPT.ai" },
+ { id: "3251706605", name: "NotFair" },
+ ],
+ defaultAccountId: "3251706605",
+ totalAccounts: 5,
+};
+
+function toolCallResult(payload: unknown): {
+ ok: true;
+ result: { content: Array<{ type: string; text: string }>; isError: boolean };
+} {
+ return {
+ ok: true,
+ result: {
+ content: [{ type: "text", text: JSON.stringify(payload) }],
+ isError: false,
+ },
+ };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe("listGoogleAdsAccounts", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ getMcpConfigMock.mockResolvedValue({
+ url: "https://notfair.co/api/mcp/google_ads",
+ token: "tok",
+ });
+ });
+
+ it("returns accounts + default_account_id on the real Demo2 shape", async () => {
+ mcpRpcMock.mockResolvedValueOnce(toolCallResult(ACCOUNTS_PAYLOAD));
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r.ok).toBe(true);
+ if (r.ok) {
+ expect(r.accounts).toHaveLength(5);
+ expect(r.accounts[0]).toEqual({ id: "7384288909", name: "IOW" });
+ expect(r.default_account_id).toBe("3251706605");
+ }
+ });
+
+ it("falls back to id when name is empty", async () => {
+ mcpRpcMock.mockResolvedValueOnce(
+ toolCallResult({ accounts: [{ id: "123" }], defaultAccountId: null }),
+ );
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r.ok).toBe(true);
+ if (r.ok) {
+ expect(r.accounts[0]).toEqual({ id: "123", name: "123" });
+ }
+ });
+
+ it("returns mcp_not_configured when getMcpConfig returns null", async () => {
+ getMcpConfigMock.mockResolvedValueOnce(null);
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r).toMatchObject({ ok: false, kind: "mcp_not_configured" });
+ expect(mcpRpcMock).not.toHaveBeenCalled();
+ });
+
+ it("returns rpc error when mcpRpc fails", async () => {
+ mcpRpcMock.mockResolvedValueOnce({
+ ok: false,
+ kind: "http_error",
+ status: 401,
+ });
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r).toMatchObject({ ok: false, kind: "rpc" });
+ });
+
+ it("returns shape error when payload is missing accounts array", async () => {
+ mcpRpcMock.mockResolvedValueOnce(toolCallResult({ totalAccounts: 0 }));
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r).toMatchObject({ ok: false, kind: "shape" });
+ });
+
+ it("returns shape error when JSON is malformed", async () => {
+ mcpRpcMock.mockResolvedValueOnce({
+ ok: true,
+ result: {
+ content: [{ type: "text", text: "not json" }],
+ isError: false,
+ },
+ });
+ const r = await listGoogleAdsAccounts("acme");
+ expect(r).toMatchObject({ ok: false, kind: "shape" });
+ });
+});
+
+describe("setOnboardingAccountAction", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ getMcpConfigMock.mockResolvedValue({
+ url: "https://notfair.co/api/mcp/google_ads",
+ token: "tok",
+ });
+ getProjectMock.mockReturnValue({
+ id: "uuid",
+ slug: "acme",
+ display_name: "Acme",
+ created_at: "now",
+ archived_at: null,
+ google_ads_account_id: null,
+ });
+ setProjectGoogleAdsAccountMock.mockReturnValue({
+ id: "uuid",
+ slug: "acme",
+ display_name: "Acme",
+ created_at: "now",
+ archived_at: null,
+ google_ads_account_id: "3251706605",
+ });
+ mcpRpcMock.mockResolvedValue(toolCallResult(ACCOUNTS_PAYLOAD));
+ });
+
+ it("persists the selection when account is in the bearer's list", async () => {
+ const r = await setOnboardingAccountAction("acme", "3251706605");
+ expect(r.ok).toBe(true);
+ expect(setProjectGoogleAdsAccountMock).toHaveBeenCalledWith(
+ "acme",
+ "3251706605",
+ );
+ });
+
+ it("rejects an account id NOT in the bearer's list (tamper defense)", async () => {
+ const r = await setOnboardingAccountAction("acme", "9999999999");
+ expect(r.ok).toBe(false);
+ if (!r.ok) expect(r.error).toMatch(/isn't in this bearer/i);
+ expect(setProjectGoogleAdsAccountMock).not.toHaveBeenCalled();
+ });
+
+ it("rejects when project doesn't exist", async () => {
+ getProjectMock.mockReturnValueOnce(null);
+ const r = await setOnboardingAccountAction("missing", "3251706605");
+ expect(r.ok).toBe(false);
+ if (!r.ok) expect(r.error).toMatch(/not found/i);
+ expect(mcpRpcMock).not.toHaveBeenCalled();
+ });
+
+ it("rejects on empty slug or account id", async () => {
+ const r1 = await setOnboardingAccountAction("", "3251706605");
+ expect(r1.ok).toBe(false);
+ const r2 = await setOnboardingAccountAction("acme", "");
+ expect(r2.ok).toBe(false);
+ });
+
+ it("surfaces MCP errors when listing accounts fails during validation", async () => {
+ mcpRpcMock.mockResolvedValueOnce({
+ ok: false,
+ kind: "http_error",
+ status: 500,
+ });
+ const r = await setOnboardingAccountAction("acme", "3251706605");
+ expect(r.ok).toBe(false);
+ if (!r.ok) expect(r.error).toMatch(/couldn't verify/i);
+ expect(setProjectGoogleAdsAccountMock).not.toHaveBeenCalled();
+ });
+});
+
+afterEach(() => {
+ vi.clearAllMocks();
+});
diff --git a/src/server/onboarding/accounts.ts b/src/server/onboarding/accounts.ts
new file mode 100644
index 00000000..5ffc5092
--- /dev/null
+++ b/src/server/onboarding/accounts.ts
@@ -0,0 +1,163 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+
+import { getMcpConfig, mcpRpc } from "@/server/mcp/rpc";
+import { storedMcpKey } from "@/server/mcp-catalog";
+import { getProject, setProjectGoogleAdsAccount } from "@/server/db/projects";
+import type { Project } from "@/types";
+
+/**
+ * Google Ads account picker for onboarding step=account.
+ *
+ * notfair.co's MCP bearer can grant access to multiple customer accounts
+ * (Demo2 case: 5 accounts under one bearer). The onboarding flow asks the
+ * user to pick one and we persist the choice on `projects.google_ads_account_id`
+ * so the audit + later automation target the right account.
+ *
+ * Single source of truth for the account ID is the DB column. MCP returns
+ * a `defaultAccountId` we surface only as a hint; we never silently use it.
+ */
+
+export type GoogleAdsAccount = { id: string; name: string };
+
+export type ListAccountsResult =
+ | { ok: true; accounts: GoogleAdsAccount[]; default_account_id: string | null }
+ | { ok: false; error: string; kind: "mcp_not_configured" | "rpc" | "shape" };
+
+type ListAccountsToolResult = {
+ content?: Array<{ type?: string; text?: string }>;
+ isError?: boolean;
+};
+
+type AccountsPayload = {
+ accounts?: Array<{ id?: unknown; name?: unknown }>;
+ defaultAccountId?: unknown;
+ totalAccounts?: unknown;
+};
+
+const MCP_CATALOG_KEY = "notfair-googleads";
+const LIST_TIMEOUT_MS = 8_000;
+
+/**
+ * Call the MCP's listConnectedAccounts tool with the project's stored bearer.
+ * Returns the account list (id + name) + the MCP's default-account hint.
+ */
+export async function listGoogleAdsAccounts(
+ project_slug: string,
+): Promise<ListAccountsResult> {
+ const cfg = await getMcpConfig(storedMcpKey(project_slug, MCP_CATALOG_KEY));
+ if (!cfg) {
+ return {
+ ok: false,
+ kind: "mcp_not_configured",
+ error: "Google Ads MCP is not configured for this project.",
+ };
+ }
+
+ const rpcResult = await mcpRpc<ListAccountsToolResult>(
+ cfg.url,
+ cfg.token,
+ "tools/call",
+ { name: "listConnectedAccounts", arguments: {} },
+ { timeoutMs: LIST_TIMEOUT_MS },
+ );
+
+ if (!rpcResult.ok) {
+ const message =
+ rpcResult.kind === "http_error"
+ ? `HTTP ${rpcResult.status}`
+ : rpcResult.kind === "rpc_error"
+ ? `RPC ${rpcResult.code}: ${rpcResult.message}`
+ : rpcResult.kind === "timeout"
+ ? "MCP call timed out"
+ : rpcResult.kind === "aborted"
+ ? "MCP call aborted"
+ : rpcResult.kind === "malformed_response"
+ ? rpcResult.message
+ : rpcResult.message;
+ return { ok: false, kind: "rpc", error: message };
+ }
+
+ const parsed = parseAccountsPayload(rpcResult.result);
+ if (!parsed) {
+ return {
+ ok: false,
+ kind: "shape",
+ error: "MCP listConnectedAccounts returned an unexpected shape.",
+ };
+ }
+ return { ok: true, ...parsed };
+}
+
+function parseAccountsPayload(
+ result: ListAccountsToolResult,
+): { accounts: GoogleAdsAccount[]; default_account_id: string | null } | null {
+ if (!result || typeof result !== "object") return null;
+ if (result.isError) return null;
+ const text = result.content?.[0]?.text;
+ if (typeof text !== "string") return null;
+ let body: AccountsPayload;
+ try {
+ body = JSON.parse(text) as AccountsPayload;
+ } catch {
+ return null;
+ }
+ if (!body || typeof body !== "object" || !Array.isArray(body.accounts)) {
+ return null;
+ }
+ const accounts: GoogleAdsAccount[] = [];
+ for (const a of body.accounts) {
+ if (!a || typeof a !== "object") continue;
+ const id = String(a.id ?? "").trim();
+ const name = String(a.name ?? "").trim() || id;
+ if (id) accounts.push({ id, name });
+ }
+ const default_account_id =
+ typeof body.defaultAccountId === "string" || typeof body.defaultAccountId === "number"
+ ? String(body.defaultAccountId)
+ : null;
+ return { accounts, default_account_id };
+}
+
+export type SetAccountResult =
+ | { ok: true; project: Project }
+ | { ok: false; error: string };
+
+/**
+ * Persist the selected Google Ads customer ID on the project row. Validates
+ * the account_id against the MCP's accounts list to prevent the UI from
+ * stashing a stale or fabricated id.
+ */
+export async function setOnboardingAccountAction(
+ project_slug: string,
+ account_id: string,
+): Promise<SetAccountResult> {
+ if (!project_slug.trim() || !account_id.trim()) {
+ return { ok: false, error: "Missing project slug or account id." };
+ }
+ const project = getProject(project_slug);
+ if (!project) return { ok: false, error: "Project not found." };
+
+ // Validate the account exists for this bearer. Defends against URL/form
+ // tampering that would otherwise let a user persist any string here.
+ const list = await listGoogleAdsAccounts(project_slug);
+ if (!list.ok) {
+ return {
+ ok: false,
+ error: `Couldn't verify account against MCP: ${list.error}`,
+ };
+ }
+ const match = list.accounts.find((a) => a.id === account_id);
+ if (!match) {
+ return {
+ ok: false,
+ error: `Account ${account_id} isn't in this bearer's reachable accounts.`,
+ };
+ }
+
+ const updated = setProjectGoogleAdsAccount(project_slug, match.id);
+ if (!updated) return { ok: false, error: "Project not found." };
+ revalidatePath("/", "layout");
+ return { ok: true, project: updated };
+}
diff --git a/src/server/onboarding/audit.test.ts b/src/server/onboarding/audit.test.ts
index dbdd0129..b5cac680 100644
--- a/src/server/onboarding/audit.test.ts
+++ b/src/server/onboarding/audit.test.ts
@@ -339,6 +339,30 @@ describe("runAudit", () => {
});
});
+ describe("accountId plumbing (multi-account bearers, Demo2 fix)", () => {
+ beforeEach(() => {
+ mcpRpcMock.mockResolvedValue(mockToolCallResult(NORMAL_REPORTS));
+ });
+
+ it("omits accountId from runScript args when option is null/undefined", async () => {
+ await collect("acme");
+ const [, , , params] = mcpRpcMock.mock.calls[0]!;
+ const args = (params as { arguments: Record<string, unknown> }).arguments;
+ expect(args).not.toHaveProperty("accountId");
+ });
+
+ it("passes accountId to runScript when option is provided", async () => {
+ const events: AuditEvent[] = [];
+ for await (const e of runAudit("acme", undefined, { accountId: "7073485715" })) {
+ events.push(e);
+ }
+ const [, , , params] = mcpRpcMock.mock.calls[0]!;
+ const args = (params as { arguments: Record<string, unknown> }).arguments;
+ expect(args.accountId).toBe("7073485715");
+ expect(events.some((e) => e.type === "audit:complete")).toBe(true);
+ });
+ });
+
describe("regression — real MCP envelope shape", () => {
it("unwraps the runScript {ok, result} envelope (Demo2 bug — 2026-05-19)", async () => {
// Build a payload WITHOUT the helper so we can exercise the unwrap path
diff --git a/src/server/onboarding/audit.ts b/src/server/onboarding/audit.ts
index 414f57bc..7f9d0315 100644
--- a/src/server/onboarding/audit.ts
+++ b/src/server/onboarding/audit.ts
@@ -204,6 +204,16 @@ type McpToolCallResult = {
isError?: boolean;
};
+export type RunAuditOptions = {
+ /**
+ * The Google Ads customer ID to audit. When omitted, MCP picks the bearer's
+ * default account — fine for single-account bearers but the multi-account
+ * Demo2 case made this misleading. The onboarding flow now stores the
+ * user's selection on projects.google_ads_account_id and passes it here.
+ */
+ accountId?: string | null;
+};
+
/**
* Run the audit and yield events. Caller is responsible for piping events
* to whichever surface the user is watching (SSE, log, etc).
@@ -211,6 +221,7 @@ type McpToolCallResult = {
export async function* runAudit(
project_slug: string,
signal?: AbortSignal,
+ options: RunAuditOptions = {},
): AsyncGenerator<AuditEvent, void, void> {
yield { type: "audit:start" };
@@ -224,11 +235,19 @@ export async function* runAudit(
return;
}
+ const runScriptArgs: Record<string, unknown> = {
+ code: AUDIT_SCRIPT,
+ timeoutMs: 45_000,
+ };
+ if (options.accountId) {
+ runScriptArgs.accountId = options.accountId;
+ }
+
const rpcResult = await mcpRpc<McpToolCallResult>(
cfg.url,
cfg.token,
"tools/call",
- { name: "runScript", arguments: { code: AUDIT_SCRIPT, timeoutMs: 45_000 } },
+ { name: "runScript", arguments: runScriptArgs },
{ timeoutMs: MCP_TIMEOUT_MS, signal },
);
diff --git a/src/types/index.ts b/src/types/index.ts
index 46311132..aba6045d 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -6,6 +6,14 @@ export type Project = {
display_name: string;
created_at: string;
archived_at: string | null;
+ /**
+ * Selected Google Ads customer ID for this project. Bearers from
+ * notfair.co/api/mcp/google_ads can grant access to multiple customer
+ * accounts; the onboarding flow asks the user to pick one and persists
+ * it here so the audit + later automation target the right account.
+ * Null until the user picks (or until /onboarding gets re-run).
+ */
+ google_ads_account_id: string | null;
};
export type TaskStatus =