@exposify/next 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,126 +1,23 @@
-import { ProposedField, LoginField, DocSource, RouteMarker, AgentReadyOptions } from '@exposify/core';
+import { RouteMarker, AgentReadyOptions } from '@exposify/core';
 export { HostedAuthResolverConfig, completeMcpLogin, createHostedAuthResolver, describe, exposed, hidden, hostedBroker } from '@exposify/core';
-import { A as ActionField } from './fields-olvyFnxj.js';
+import { E as ExposifyManifest } from './manifest-DZQCvzQy.js';
+export { a as AppRouteEntry, b as ManifestAction, c as ManifestLogin, d as ManifestLoginStep, e as ManifestPage, f as ManifestRoute, P as PagesRouteEntry } from './manifest-DZQCvzQy.js';
 
-interface AppRouteEntry {
-    router: "app";
-    /** `/api/orders/:id`; catch-alls as `:slug*`, optional ones as `:slug*?`. */
-    path: string;
-    params: string[];
-    /** Project-relative, for messages. */
-    file: string;
-    /** Exported methods when generated; the loaded module's exports win at runtime. */
-    methods: string[];
-    /** Loads the route module to read exposed()/hidden()/describe() off its exports. Absent for edge routes. */
-    load?: () => Promise<Record<string, unknown>>;
-    /** `export const runtime = "edge"`: not loaded into the Node MCP route, so markers there aren't read. */
-    edge?: boolean;
-}
-interface PagesRouteEntry {
-    router: "pages";
-    path: string;
-    params: string[];
-    file: string;
-}
-type ManifestRoute = AppRouteEntry | PagesRouteEntry;
-/** An exported function of a `"use server"` module. */
-interface ManifestAction {
-    /** Unique among actions: the default tool name, and the URL segment under `<mcpPath>/actions/`. */
-    key: string;
-    file: string;
-    export: string;
-    /** How each parameter is filled on a call, in order: see `ActionParamRole` in parse.ts. */
-    params: Array<{
-        name: string;
-        role: "formData" | "prev" | "input" | "object";
-    }>;
-    /** It sets or deletes a cookie, which would land on exposify's internal call rather than the agent's client. */
-    setsCookies?: boolean;
-    /** What it takes, worked out from its code (fields.ts): its tool schema when the app doesn't write one. */
-    fields: ActionField[];
-    /** It reads every form field, so its code doesn't say which exist. */
-    readsAll?: boolean;
-    /** What the analysis couldn't work out ("line N: …"): with any, the app writes the schema. */
-    unresolved?: string[];
-    /** The forms that submit to it (pass 3), where they are. */
-    forms?: Array<{
-        file: string;
-        line: number;
-    }>;
-    /** An input `describe` proposed and a person accepted, current with the code: used when `fields` can't be the schema. */
-    proposed?: ProposedField[];
-    /**
-     * A page that uses it (`/checkout`, `/admin/orders/:id`): tool calls are
-     * sent there as a real Server Action request. Absent when no page uses it;
-     * it's then called in-process by the MCP route.
-     */
-    host?: string;
-    /**
-     * The app's own checks it runs first (`lib/auth.ts#requireAdmin`): a
-     * user who doesn't pass one doesn't see the tool (guards.ts).
-     */
-    guards?: string[];
-    load: () => Promise<Record<string, unknown>>;
-}
-/** An App Router page: a read tool that fetches it like a browser (pages.ts). */
-interface ManifestPage {
-    /** Tool name, e.g. `view_product_slug`. */
-    name: string;
-    /** `/product/:slug`, as routes are written. */
-    path: string;
-    params: string[];
-    file: string;
-    /** Search params its code reads: optional tool arguments, sent as the query. */
-    search?: string[];
-    /** From its static `metadata`. */
-    title?: string;
-    description?: string;
-    /** Just a form posting to a Server Action: not a tool unless `pages` lists it. */
-    formOnly?: boolean;
-    /** The app's own checks it runs (`lib/auth.ts#requireAdmin`), see ManifestAction.guards. */
-    guards?: string[];
-}
+/** Header carrying `<ip>;<unix seconds>;<signature>` on a tool call. */
+declare const AGENT_IP_HEADER = "x-exposify-agent-ip";
 /**
- * The app's own login (login.ts): a sign-in form under the MCP route makes
- * this request, for Connect with no code. `host` is the page with the
- * action's form, which tool calls redirected to mean "signed out".
+ * The address of whoever made this request: on a tool call, the AI agent's
+ * (verified with EXPOSIFY_KEY, so it can't be forged); otherwise the
+ * platform's `x-forwarded-for`, as you'd read it anyway. Use it where a
+ * route rate-limits or logs by IP: on Vercel, a tool call's own
+ * `x-forwarded-for` is the function's address, not the agent's.
  */
-type ManifestLogin = ({
-    kind: "action";
-    key: string;
-    fields: LoginField[];
-    host?: string;
-} | {
-    kind: "route";
-    path: string;
-    fields: LoginField[];
-    body: "json" | "form";
-}) & {
-    /** Where it is, for the startup log and the dashboard: "signIn in app/actions/auth.ts". */
-    where?: string;
-};
-interface ExposifyManifest {
-    info: {
-        name: string;
-        version: string;
-    };
-    /** next.config's basePath, prefixed to every tool call's path. */
-    basePath?: string;
-    /** next.config's trailingSlash: tool calls add one, so they aren't redirected. */
-    trailingSlash?: boolean;
-    routes: ManifestRoute[];
-    /** The MCP route's URL without its catch-all segment, e.g. `/mcp`: Server Actions are served under `<mcpPath>/actions/`. */
-    mcpPath?: string;
-    actions?: ManifestAction[];
-    pages?: ManifestPage[];
-    login?: ManifestLogin;
-    /** Auth libraries in package.json ("next-auth", "@supabase/ssr", ...), reported with the login. */
-    authStacks?: string[];
-    /** Docs for search_docs, embedded so they work without a file system. */
-    docs: DocSource[];
-    /** exposify.descriptions.json's texts, "METHOD /path" -> text. */
-    descriptions?: Record<string, string>;
-}
+declare function agentIp(request: {
+    headers: Headers;
+}, options?: {
+    key?: string;
+    now?: number;
+}): Promise<string | undefined>;
 
 /** Set on every tool call; the MCP route refuses requests carrying it, so a tool can never call the MCP endpoint. */
 declare const DISPATCH_HEADER = "x-exposify-dispatch";
@@ -189,6 +86,29 @@ interface NextAiReadyOptions extends Omit<AgentReadyOptions, "docs"> {
         fields: string[];
         body?: "json" | "form";
     };
+    /**
+     * The login's second step, when it asks for a code after the first (a
+     * password, then a code; or an email, then a code). Found by
+     * `withExposify` (a Server Action or POST route named like `verify`,
+     * `2fa`, `otp` that takes one code and sets the session). Name another
+     * Server Action, a route (`{ path, fields }`), or `false` for none.
+     */
+    loginVerify?: false | string | {
+        path: string;
+        fields: string[];
+        body?: "json" | "form";
+    };
+    /**
+     * The app's Supabase project, for Connect when the app uses Supabase Auth
+     * with `@supabase/ssr`: AI assistants sign in to it directly, and tool
+     * calls carry the session cookie `@supabase/ssr` reads. Default: read from
+     * `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY`
+     * (or `NEXT_PUBLIC_SUPABASE_ANON_KEY`). `false` to not offer it.
+     */
+    supabase?: false | {
+        url: string;
+        key: string;
+    };
 }
 interface NextPageOptions {
     /** Tool name. Default: `view_` and the path, snake_cased. */
@@ -198,4 +118,4 @@ interface NextPageOptions {
 type NextMcpHandler = (req: Request) => Promise<Response>;
 declare function aiReady(manifest: ExposifyManifest, options?: NextAiReadyOptions): NextMcpHandler;
 
-export { type AppRouteEntry, DISPATCH_HEADER, type ExposifyManifest, type ManifestAction, type ManifestLogin, type ManifestPage, type ManifestRoute, type NextActionOptions, type NextAiReadyOptions, type NextMcpHandler, type NextPageOptions, type PagesRouteEntry, aiReady };
+export { AGENT_IP_HEADER, DISPATCH_HEADER, ExposifyManifest, type NextActionOptions, type NextAiReadyOptions, type NextMcpHandler, type NextPageOptions, agentIp, aiReady };

package/dist/index.js

@@ -20,10 +20,18 @@ import {
   handleLoginPage,
   hostedResolverInfo,
   loginResultFromResponse,
+  keepFailedCookies,
+  readStep,
+  rejectedBody,
+  readSupabaseAuth,
   reportAppLogin,
   samePath,
+  sessionFrom,
   setCookieLines,
   SIGNED_OUT_HEADER,
+  supabaseCookieName,
+  supabasePasswordLogin,
+  verifyFields,
   matchesPathGlob,
   formatFailed,
   formatReady,
@@ -638,6 +646,49 @@ async function readPageResponse(res, url) {
   return Response.json(body);
 }
 
+// src/agent-ip.ts
+var AGENT_IP_HEADER = "x-exposify-agent-ip";
+var MAX_AGE_S = 300;
+function env2() {
+  return globalThis.process?.env ?? {};
+}
+var keyCache = /* @__PURE__ */ new Map();
+function hmacKey(secret) {
+  let key = keyCache.get(secret);
+  if (!key) {
+    key = (async () => {
+      const material = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`exposify agent-ip v1
+${secret}`));
+      return crypto.subtle.importKey("raw", material, { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+    })();
+    keyCache.set(secret, key);
+  }
+  return key;
+}
+var hex2 = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+async function signAgentIp(ip, secret = env2().EXPOSIFY_KEY, now = Date.now()) {
+  if (!ip || !secret || /[;\s]/.test(ip) || ip.length > 64) return null;
+  const t = Math.floor(now / 1e3);
+  const sig = await crypto.subtle.sign("HMAC", await hmacKey(secret), new TextEncoder().encode(`${ip};${t}`));
+  return `${ip};${t};${hex2(sig)}`;
+}
+function forwardedIp(headers) {
+  return headers.get("x-forwarded-for")?.split(",")[0]?.trim() || headers.get("x-real-ip")?.trim() || void 0;
+}
+async function agentIp(request, options = {}) {
+  const signed = request.headers.get(AGENT_IP_HEADER);
+  const secret = options.key ?? env2().EXPOSIFY_KEY;
+  if (signed && secret) {
+    const [ip, t, sig] = signed.split(";");
+    const age = Math.floor((options.now ?? Date.now()) / 1e3) - Number(t);
+    if (ip && sig && /^[0-9a-f]{64}$/.test(sig) && Number.isInteger(Number(t)) && age >= -60 && age <= MAX_AGE_S) {
+      const bytes = new Uint8Array(sig.match(/../g).map((b) => parseInt(b, 16)));
+      if (await crypto.subtle.verify("HMAC", await hmacKey(secret), bytes, new TextEncoder().encode(`${ip};${t}`))) return ip;
+    }
+  }
+  return forwardedIp(request.headers);
+}
+
 // src/index.ts
 import {
   exposed,
@@ -653,7 +704,7 @@ var LOG_PREFIX = "[agentready]";
 var ACTION_NOTE = "It returns the action's result, or { ok: true, redirectedTo } when the action redirects; a redirect to a sign-in page means the call wasn't authorised.";
 var LEFT_BLANK = "A field you leave out is as if left blank on the form.";
 var PAGE_NOTE = "Returns the page's main content as text, with links, and the data it was rendered with when the page passes any to its components. An error naming a sign-in page means signing in first.";
-function env2() {
+function env3() {
   return globalThis.process?.env ?? {};
 }
 function errorMessage(err) {
@@ -716,7 +767,7 @@ function derivedInput(action) {
     const fields = action.proposed.map((p) => ({ name: p.name, type: p.type, ...p.required ? { required: true } : {}, ...p.enum ? { enum: p.enum } : {}, ...p.description ? { description: p.description } : {} }));
     return { input: Object.fromEntries(fields.map((f) => [f.name, fieldSchema(f)])) };
   }
-  if (reason) return { reason: action.fields.some((f) => f.type === "file") ? reason : `${reason}; \`exposify-next describe\` can propose it for you to review` };
+  if (reason) return { reason: action.fields.some((f) => f.type === "file") ? reason : `${reason}; \`@exposify/next describe\` can propose it for you to review` };
   return { input: Object.fromEntries(action.fields.map((f) => [f.name, fieldSchema(f)])) };
 }
 var sentence = (s) => /[.!?]$/.test(s.trim()) ? s.trim() : `${s.trim()}.`;
@@ -836,29 +887,65 @@ function pagesFrom(manifest, cfg, config) {
   }
   return { routes, hidden: hidden3, forms };
 }
-function loginSpec(manifest, config, warnings) {
+function loginSpec(manifest, options, warnings) {
+  const config = options.login;
   if (config === false) return null;
-  if (config === void 0) return manifest.login ?? null;
+  let login;
+  if (config === void 0) login = manifest.login ?? null;
+  else {
+    const step = stepSpec(manifest, config, (name) => fieldKind(name), warnings, "login", "AI assistants can't sign in with your app's login");
+    login = step ? { ...step.step, where: step.where } : null;
+  }
+  if (!login || options.loginVerify === void 0) return login;
+  const { verify: _found, ...first } = login;
+  if (options.loginVerify === false) return first;
+  const kind = (name) => verifyFields([name], true)?.[0]?.kind ?? fieldKind(name);
+  const verify = stepSpec(manifest, options.loginVerify, kind, warnings, "loginVerify", "AI assistants can't finish your app's two-step login");
+  return verify ? { ...first, verify: verify.step, where: `${first.where ?? "your login"}, then a code: ${verify.where}` } : first;
+}
+function supabaseSpec(manifest, options, warnings) {
+  if (!manifest.supabase || options.supabase === false) return null;
+  if (options.supabase) return options.supabase;
+  const e = env3();
+  const url = e.NEXT_PUBLIC_SUPABASE_URL ?? e.SUPABASE_URL;
+  const key = e.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY ?? e.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? e.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_OR_ANON_KEY;
+  if (!url || !key) {
+    warnings.push("your app uses Supabase Auth, but NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY (or _ANON_KEY) aren't both set where the MCP route runs, so AI assistants can't sign in to it; set them, or pass aiReady({ supabase: { url, key } })");
+    return null;
+  }
+  try {
+    new URL(url);
+  } catch {
+    warnings.push(`NEXT_PUBLIC_SUPABASE_URL isn't a URL (${url}), so AI assistants can't sign in to your Supabase Auth`);
+    return null;
+  }
+  return { url, key };
+}
+function stepSpec(manifest, config, kind, warnings, option, consequence) {
   if (typeof config === "object") {
-    const fields2 = config.fields.map((name) => ({ name, kind: fieldKind(name) }));
-    return { kind: "route", path: config.path, fields: fields2, body: config.body ?? "json", where: `POST ${config.path}` };
+    const fields2 = config.fields.map((name) => ({ name, kind: kind(name) }));
+    return { step: { kind: "route", path: config.path, fields: fields2, body: config.body ?? "json" }, where: `POST ${config.path}` };
   }
   const action = (manifest.actions ?? []).find((a) => a.key === config || a.export === config);
   if (!action) {
-    warnings.push(`aiReady({ login: "${config}" }): no server action by that name, so AI assistants can't sign in with your app's login`);
+    warnings.push(`aiReady({ ${option}: "${config}" }): no server action by that name, so ${consequence}`);
     return null;
   }
-  const fields = action.fields.map((f) => ({ name: f.name, kind: fieldKind(f.name) }));
-  return { kind: "action", key: action.key, fields, ...action.host ? { host: action.host } : {}, where: `${action.export} in ${action.file}` };
+  const fields = action.fields.map((f) => ({ name: f.name, kind: kind(f.name) }));
+  return { step: { kind: "action", key: action.key, fields, ...action.host ? { host: action.host } : {} }, where: `${action.export} in ${action.file}` };
 }
-async function actionLoginResult(raw, exportName) {
+async function actionLoginResult(raw, exportName, reading = {}) {
   if (actionNotFound(raw)) return { ok: false, message: "The app's sign-in page didn't run its login. Its developer needs to rebuild the app." };
-  const cookies = cookieChanges(raw).filter((c) => !c.deleted && c.value !== "");
+  const changes = cookieChanges(raw);
   const out = await readActionResponse(raw, exportName);
   const body = await out.json().catch(() => void 0);
+  const location = raw.headers.get("x-action-redirect")?.split(";")[0] ?? (typeof body?.redirectedTo === "string" ? body.redirectedTo : null);
+  const step = readStep({ status: location ? 303 : out.status, location, body, cookies: changes }, reading);
+  if (step) return keepFailedCookies(step, changes, reading);
   const message = errorMessageOf(body);
-  if (out.status >= 400 || message && !body?.redirectedTo) return { ok: false, message };
-  return cookies.length > 0 ? { ok: true, session: { cookies } } : { ok: false, message };
+  if (out.status >= 400 || message && !body?.redirectedTo || rejectedBody(body)) return keepFailedCookies({ ok: false, message }, changes, reading);
+  const session = sessionFrom(changes, reading, Boolean(location) || body !== void 0 && body !== null && typeof body === "object");
+  return session ? { ok: true, session } : keepFailedCookies({ ok: false, message }, changes, reading);
 }
 var clientIp = (headers) => headers.get("x-forwarded-for")?.split(",")[0]?.trim() || headers.get("x-real-ip") || void 0;
 function aiReady(manifest, options = {}) {
@@ -871,9 +958,39 @@ function aiReady(manifest, options = {}) {
   const actionsBase = (manifest.mcpPath ?? "").replace(/\/$/, "");
   const actionUrl = manifest.mcpPath === void 0 ? null : new RegExp(`${actionsBase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/actions/([^/]+)/?$`);
   const loginWarnings = [];
-  const login = hostedResolverInfo(cfg.auth) ? loginSpec(manifest, options.login, loginWarnings) : null;
+  const login = hostedResolverInfo(cfg.auth) ? loginSpec(manifest, options, loginWarnings) : null;
   const loginPagePath = `${(manifest.mcpPath ?? "/mcp").replace(/\/$/, "")}/login`;
   if (login) cfg.signedOutPaths = [login.kind === "action" ? login.host : login.path].filter((p) => Boolean(p)).map((p) => `${manifest.basePath ?? ""}${hostPath(p)}`);
+  const supabase = hostedResolverInfo(cfg.auth) ? supabaseSpec(manifest, options, loginWarnings) : null;
+  if (supabase && manifest.supabase?.loginPages?.length) {
+    cfg.signedOutPaths = [...cfg.signedOutPaths ?? [], ...manifest.supabase.loginPages.map((p) => `${manifest.basePath ?? ""}${hostPath(p)}`)];
+  }
+  const supabasePassword = supabase ? supabasePasswordLogin({
+    ...supabase,
+    onCaptcha: () => warnOnce("your Supabase project asks for a CAPTCHA to sign in, so AI assistants can't sign in with a password; social sign-ins still work")
+  }) : null;
+  const supabaseLoginNow = () => {
+    if (!supabasePassword) return null;
+    const choice = hostedResolverInfo(cfg.auth)?.supabasePasswordDirect();
+    return choice ?? (!login && manifest.supabase?.direct.includes("password")) ? supabasePassword : null;
+  };
+  let supabaseAuth;
+  const supabaseReport = () => {
+    if (!supabase || !manifest.supabase) return Promise.resolve(void 0);
+    const found = manifest.supabase;
+    supabaseAuth ??= readSupabaseAuth(supabase.url, supabase.key).then((read) => {
+      if (!read) {
+        supabaseAuth = void 0;
+        return void 0;
+      }
+      return {
+        ...read,
+        cookie: found.cookieName ?? supabaseCookieName(supabase.url),
+        found: { direct: found.direct, where: found.found, ...found.unusable ? { unusable: found.unusable } : {}, ...found.callbacks ? { callbacks: found.callbacks } : {} }
+      };
+    });
+    return supabaseAuth;
+  };
   let built = null;
   const build = async (endpoint) => {
     const warnings = [...loginWarnings];
@@ -967,7 +1084,7 @@ function aiReady(manifest, options = {}) {
         formatWarning(
           LOG_PREFIX,
           `MCP is up at ${endpoint} but exposes no route tools`,
-          "check that exposify.generated.ts is current (withExposify() in next.config, or `npx exposify-next generate`)"
+          "check that exposify.generated.ts is current (withExposify() in next.config, or `npx @exposify/next generate`)"
         )
       );
       return;
@@ -977,11 +1094,16 @@ function aiReady(manifest, options = {}) {
     if (cfg.expose === "*") details.push('all write routes exposed (expose: "*")');
     if (counts.hiddenWrites > 0) details.push(`${counts.hiddenWrites} write route${counts.hiddenWrites === 1 ? "" : "s"} hidden (opt in with exposed())`);
     if (pages.routes.length > 0) details.push(`${pages.routes.length} page${pages.routes.length === 1 ? "" : "s"} readable`);
-    if (login) details.push(`AI assistants sign in with your app's own login (${login.kind === "action" ? `server action ${login.key}` : `POST ${login.path}`}) at ${loginPagePath}`);
+    if (supabaseLoginNow()) {
+      details.push(`AI assistants sign in to your Supabase Auth with a password at ${loginPagePath}`);
+    } else if (login) {
+      const step = (l) => l.kind === "action" ? `server action ${l.key}` : `POST ${l.path}`;
+      details.push(`AI assistants sign in with your app's own login (${step(login)}${login.verify ? `, then a code: ${step(login.verify)}` : ""}) at ${loginPagePath}`);
+    }
     if (pages.forms > 0) details.push(`${pages.forms} page${pages.forms === 1 ? "" : "s"} left out as just a form (list in aiReady({ pages }) to include)`);
     if (exposedActions > 0) details.push(`${exposedActions} server action${exposedActions === 1 ? "" : "s"} exposed, each checking auth itself`);
     if (hiddenActions > 0) details.push(`${hiddenActions} server action${hiddenActions === 1 ? "" : "s"} hidden (opt in with aiReady({ actions }))`);
-    const e = env2();
+    const e = env3();
     if (e.VERCEL && e.VERCEL_ENV !== "production" && !e.VERCEL_AUTOMATION_BYPASS_SECRET) {
       details.push("on a protected Vercel preview, tool calls need VERCEL_AUTOMATION_BYPASS_SECRET");
     }
@@ -991,7 +1113,7 @@ function aiReady(manifest, options = {}) {
   const selfFetch = async (request, mcpReq, route) => {
     const target = new URL(request.url);
     const incoming = new URL(mcpReq.url);
-    const origin = options.baseUrl ?? env2().EXPOSIFY_BASE_URL ?? incoming.origin;
+    const origin = options.baseUrl ?? env3().EXPOSIFY_BASE_URL ?? incoming.origin;
     let path = `${manifest.basePath ?? ""}${target.pathname}`;
     if (manifest.trailingSlash && !path.endsWith("/")) path += "/";
     const headers = new Headers(request.headers);
@@ -1002,8 +1124,11 @@ function aiReady(manifest, options = {}) {
     }
     headers.set("x-forwarded-proto", mcpReq.headers.get("x-forwarded-proto") ?? incoming.protocol.slice(0, -1));
     headers.set("x-forwarded-host", mcpReq.headers.get("x-forwarded-host") ?? mcpReq.headers.get("host") ?? incoming.host);
-    const bypass = env2().VERCEL_AUTOMATION_BYPASS_SECRET;
+    const bypass = env3().VERCEL_AUTOMATION_BYPASS_SECRET;
     if (bypass) headers.set("x-vercel-protection-bypass", bypass);
+    const signedIp = await signAgentIp(clientIp(mcpReq.headers));
+    if (signedIp) headers.set(AGENT_IP_HEADER, signedIp);
+    else headers.delete(AGENT_IP_HEADER);
     const body = request.body ? await request.text() : void 0;
     const actionKey = actionUrl?.exec(target.pathname)?.[1];
     if (actionKey !== void 0) {
@@ -1046,34 +1171,34 @@ function aiReady(manifest, options = {}) {
     const reply = encodeReply(actionArguments(live.action.params, fields, jsonFieldsOf(live.action)));
     return fetch(new URL(path, origin), { method: "POST", headers: out, body: reply, redirect: "manual", cache: "no-store" });
   };
-  const appLoginFor = (req, spec) => ({
-    label: spec.kind === "action" ? `server action ${spec.key}` : `POST ${spec.path}`,
-    fields: spec.fields,
-    signedOutPaths: cfg.signedOutPaths ?? [],
-    attempt: async (values, ctx) => {
-      const target = options.baseUrl ?? env2().EXPOSIFY_BASE_URL ?? new URL(req.url).origin;
+  const appLoginFor = (req, spec) => {
+    const pathOf = (p) => {
+      let path = `${manifest.basePath ?? ""}${p}`;
+      if (manifest.trailingSlash && !path.endsWith("/")) path += "/";
+      return path;
+    };
+    const stepPath = (step) => step.kind === "action" ? step.host ? pathOf(hostPath(step.host)) : void 0 : pathOf(step.path);
+    const verifyPaths = spec.verify ? [stepPath(spec.verify)].filter((p) => Boolean(p)) : void 0;
+    const send = async (step, values, ctx, reading, cookies = []) => {
+      const target = options.baseUrl ?? env3().EXPOSIFY_BASE_URL ?? new URL(req.url).origin;
       const pub = new URL(ctx.origin);
       const headers = new Headers({ origin: pub.origin, "x-forwarded-proto": pub.protocol.slice(0, -1), "x-forwarded-host": pub.host });
       if (ctx.ip) headers.set("x-forwarded-for", ctx.ip);
       const ua = req.headers.get("user-agent");
       if (ua) headers.set("user-agent", ua);
-      const bypass = env2().VERCEL_AUTOMATION_BYPASS_SECRET;
+      if (cookies.length) headers.set("cookie", cookies.map((c) => `${c.name}=${c.value}`).join("; "));
+      const bypass = env3().VERCEL_AUTOMATION_BYPASS_SECRET;
       if (bypass) headers.set("x-vercel-protection-bypass", bypass);
-      const pathOf = (p) => {
-        let path = `${manifest.basePath ?? ""}${p}`;
-        if (manifest.trailingSlash && !path.endsWith("/")) path += "/";
-        return path;
-      };
-      if (spec.kind === "route") {
-        headers.set("content-type", spec.body === "form" ? "application/x-www-form-urlencoded" : "application/json");
-        const body = spec.body === "form" ? new URLSearchParams(values).toString() : JSON.stringify(values);
-        return loginResultFromResponse(await fetch(new URL(pathOf(spec.path), target), { method: "POST", headers, body, redirect: "manual", cache: "no-store" }));
+      if (step.kind === "route") {
+        headers.set("content-type", step.body === "form" ? "application/x-www-form-urlencoded" : "application/json");
+        const body = step.body === "form" ? new URLSearchParams(values).toString() : JSON.stringify(values);
+        return loginResultFromResponse(await fetch(new URL(pathOf(step.path), target), { method: "POST", headers, body, redirect: "manual", cache: "no-store" }), reading);
       }
-      const action = (manifest.actions ?? []).find((a) => a.key === spec.key);
+      const action = (manifest.actions ?? []).find((a) => a.key === step.key);
       const fn = action ? (await action.load())[action.export] : void 0;
       const id = fn?.$$id;
       if (!action?.host || typeof id !== "string") {
-        warnOnce(`server action ${spec.key} is your app's login, but no page uses it, so the sign-in form can't run it; use it from a page's form`);
+        warnOnce(`server action ${step.key} is part of your app's login, but no page uses it, so the sign-in form can't run it; use it from a page's form`);
         return { ok: false, message: "This app's sign-in can't be used by AI assistants yet." };
       }
       headers.set("next-action", id);
@@ -1081,9 +1206,28 @@ function aiReady(manifest, options = {}) {
       headers.set("accept", "text/x-component");
       const reply = encodeReply(actionArguments(action.params, values, jsonFieldsOf(action)));
       const raw = await fetch(new URL(pathOf(hostPath(action.host)), target), { method: "POST", headers, body: reply, redirect: "manual", cache: "no-store" });
-      return actionLoginResult(raw, action.export);
-    }
-  });
+      return actionLoginResult(raw, action.export, reading);
+    };
+    const verify = spec.verify;
+    return {
+      label: spec.kind === "action" ? `server action ${spec.key}` : `POST ${spec.path}`,
+      fields: spec.fields,
+      signedOutPaths: cfg.signedOutPaths ?? [],
+      ...spec.passwordless ? { passwordless: true } : {},
+      attempt: (values, ctx) => send(spec, values, ctx, {
+        ...verifyPaths ? { verifyPaths } : {},
+        ...verify ? { verifyFields: verify.fields.map((f) => f.name) } : {},
+        ...spec.passwordless ? { start: true } : {}
+      }),
+      ...verify ? {
+        verify: {
+          label: verify.kind === "action" ? `server action ${verify.key}` : `POST ${verify.path}`,
+          fields: verify.fields,
+          attempt: (values, ctx) => send(verify, values, ctx, { carried: ctx.carry.cookies, verifyPaths: verifyPaths ?? [] }, ctx.carry.cookies)
+        }
+      } : {}
+    };
+  };
   const carrySession = (raw, out) => {
     const lines = setCookieLines(raw);
     const redirect = raw.headers.get("x-action-redirect")?.split(";")[0];
@@ -1128,9 +1272,10 @@ function aiReady(manifest, options = {}) {
   };
   return async (req) => {
     const pathname = new URL(req.url).pathname;
-    if (login && samePath(pathname, [loginPagePath, `${manifest.basePath ?? ""}${loginPagePath}`])) {
+    const supabaseLogin = supabaseLoginNow();
+    if ((login || supabaseLogin) && samePath(pathname, [loginPagePath, `${manifest.basePath ?? ""}${loginPagePath}`])) {
       const pub = new URL(publicRequestUrl(req.url, req.headers));
-      return handleLoginPage(req, appLoginFor(req, login), hostedResolverInfo(cfg.auth), {
+      return handleLoginPage(req, supabaseLogin ?? appLoginFor(req, login), hostedResolverInfo(cfg.auth), {
         path: pub.pathname,
         secure: pub.protocol === "https:",
         origin: pub.origin,
@@ -1157,7 +1302,13 @@ function aiReady(manifest, options = {}) {
       const url = publicRequestUrl(req.url, req.headers);
       const isPrm = url.endsWith(PRM_SUFFIX);
       const resource = brokerGate.resourceFor(isPrm ? url.slice(0, -PRM_SUFFIX.length) : url);
-      const verdict = await reportAppLogin(cfg.auth, resource, login, { where: login?.where, stacks: manifest.authStacks, log: logReady });
+      const supabaseAuth2 = await supabaseReport();
+      const verdict = await reportAppLogin(cfg.auth, resource, supabaseLogin ?? login, {
+        where: supabaseLogin ? "your Supabase Auth (password)" : login?.where,
+        stacks: manifest.authStacks,
+        log: logReady,
+        ...supabaseAuth2 ? { supabase: supabaseAuth2 } : {}
+      });
       if (verdict === "open") {
         if (isPrm) return new Response("not found", { status: 404 });
       } else {
@@ -1175,7 +1326,9 @@ function aiReady(manifest, options = {}) {
   };
 }
 export {
+  AGENT_IP_HEADER,
   DISPATCH_HEADER,
+  agentIp,
   aiReady,
   completeMcpLogin,
   createHostedAuthResolver,