@fargowealth/fargo-ai-cli 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.3.0
+
+- Add `fargo website connect` and `fargo website sync` with an isolated local
+  Chrome Profile and allowlisted CDP capture.
+- Negotiate one-time Profile import capabilities through Website Bridge MCP,
+  then upload browser state directly to the Website Bridge data endpoint.
+- Keep raw Cookie/localStorage and upload secrets out of MCP parameters,
+  command output, and the Fargo credential store.
+
 ## 1.2.0
 
 - Added `--login-required yes|no` to select the target company-account sign-in

package/README.md

@@ -47,6 +47,44 @@ fargo mcp call lego_app_read --args '{"action":"get","appId":"app_xxx"}'
 fargo mcp call lego_app_read --args-file ./arguments.json
 ```
 
+## Website Connectors
+
+`fargo website` is the authoring and control surface for cloud-hosted Website
+Connectors. Connector definitions and immutable releases are stored by Fargo
+Website Bridge; per-user Cookie/localStorage remains encrypted in BrowserGateway
+and is never written to the CLI credential store or emitted as a JSON file. The
+CLI keeps a dedicated local Chrome Profile so the user can log in locally and
+synchronize later; that Profile is isolated from the user's normal Chrome data.
+
+```sh
+fargo website validate --file connector.json
+fargo website release --file connector.json --expected-revision 0 --confirm
+fargo website list
+fargo website operations --connector earningshub
+fargo website connect --connector earningshub
+fargo website sync --connector earningshub
+fargo website sync --connector earningshub --no-prompt --settle-ms 5000
+fargo website connection-status --connector earningshub
+fargo website call --connector earningshub --operation get_symbol --args '{"symbol":"AMZN"}'
+fargo website binding
+```
+
+`connect` opens the Connector login URL in a Fargo-owned local Chrome Profile.
+After login, the CLI captures only the Connector-declared Cookie and
+localStorage selectors. MCP negotiates a five-minute, single-use upload
+capability using SHA-256 digests; the Profile body then goes directly to
+`https://website-bridge.fargowealth.app` and never crosses the central MCP.
+`sync` reopens the same local Profile and uses optimistic Profile-version
+protection before replacing the encrypted cloud state. `--no-prompt` is for a
+Profile that is already authenticated.
+
+Connector operations remain brokered through App MCP `website-bridge`, so the
+same operations are available to Codex, WorkBuddy, other Agents, and Teammates.
+V1 releases are owner-private. A Teammate binding delegates the invoking user's
+identity and contains neither a `connectionId` nor website credentials. The old
+`authorize` / `authorize-complete` Cloud Live View commands remain an optional
+fallback, not the primary connection path.
+
 ## LEGO source snapshots
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fargowealth/fargo-ai-cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Agent-neutral Fargo AI CLI, MCP client, and LEGO project tooling",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -9,6 +9,7 @@ import { applyLegoMigrations, planLegoMigrations } from "./lego-migrations.mjs";
 import { callMcpTool, listMcpTools } from "./mcp-client.mjs";
 import { runMcpProxy } from "./mcp-proxy.mjs";
 import { installAgentMcp } from "./agent-install.mjs";
+import { runWebsiteCommand } from "./website-cli.mjs";
 
 export async function runCli(args, options = {}) {
   const stdout = options.stdout ?? process.stdout;
@@ -61,6 +62,10 @@ export async function runCli(args, options = {}) {
       stdout.write(`${JSON.stringify(await callMcpTool(store, toolName, toolArgs, options))}\n`);
       return;
     }
+    if (args[0] === "website") {
+      await runWebsiteCommand(args, stdout, store, options);
+      return;
+    }
     if (args[0] === "lego" && args[1] === "snapshot") {
       await runLegoSnapshotCommand(args, stdout, store, options);
       return;
@@ -126,7 +131,7 @@ export async function runCli(args, options = {}) {
       await installAgentConnection(args, "workbuddy", stdout, store, options);
       return;
     }
-    throw new Error("Usage: fargo auth login|device|status|logout | fargo agent install --agent <agent> | fargo mcp serve|tools|call | fargo lego snapshot upload|list|download | fargo lego deploy | fargo lego d1 migrate plan|apply | fargo workbuddy install | fargo version");
+    throw new Error("Usage: fargo auth login|device|status|logout | fargo agent install --agent <agent> | fargo mcp serve|tools|call | fargo website validate|release|list|operations|call|connect|sync|connection-status|authorize|authorize-complete|binding | fargo lego snapshot upload|list|download | fargo lego deploy | fargo lego d1 migrate plan|apply | fargo workbuddy install | fargo version");
   } catch (error) {
     stderr.write(`fargo: ${error instanceof Error ? error.message : "unknown error"}\n`);
     if (options.throwOnError) throw error;
@@ -140,6 +145,7 @@ Commands:
   auth login|device|status|logout
   agent install --agent <codex|claude-code|cursor|workbuddy>
   mcp serve|tools|call
+  website validate|release|list|operations|call|connect|sync|connection-status|authorize|authorize-complete|binding
   lego snapshot upload|list|download
   lego deploy
   lego d1 migrate plan|apply

package/src/constants.mjs

@@ -1,4 +1,4 @@
-export const CLI_VERSION = "1.2.0";
+export const CLI_VERSION = "1.3.0";
 export const DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
 export const DEFAULT_AUTH_URL = "https://auth.fargowealth.app";
 export const DEFAULT_API_URL = "https://mcp.fargowealth.app";

package/src/website-browser-profile.mjs

@@ -0,0 +1,346 @@
+import { spawn } from "node:child_process";
+import { access, chmod, mkdir, readFile, unlink } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+export const WEBSITE_BROWSER_PROFILE_SCHEMA_VERSION = "fargo.browser-profile/v1";
+
+export async function captureLocalWebsiteProfile(spec, options = {}) {
+  const captureSpec = parseCaptureSpec(spec);
+  const profileDirectory = resolve(options.profileDirectory ?? defaultLocalWebsiteProfileDirectory(captureSpec.connectorId, {
+    ...options,
+    profileKey: captureSpec.localProfileKey
+  }));
+  await mkdir(profileDirectory, { recursive: true, mode: 0o700 });
+  if (platform() !== "win32") await chmod(profileDirectory, 0o700);
+  const chromePath = await findChromeExecutable(options.chromePath, options);
+  const activePortPath = join(profileDirectory, "DevToolsActivePort");
+  await unlink(activePortPath).catch((error) => {
+    if (error?.code !== "ENOENT") throw error;
+  });
+  const child = spawn(chromePath, [
+    "--remote-debugging-address=127.0.0.1",
+    "--remote-debugging-port=0",
+    `--user-data-dir=${profileDirectory}`,
+    ...(options.headless ? ["--headless=new"] : []),
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--new-window",
+    captureSpec.loginUrl
+  ], { stdio: "ignore" });
+  let client;
+  try {
+    const endpoint = await waitForDevToolsEndpoint(activePortPath, child, options);
+    client = await CdpClient.connect(endpoint);
+    const sessionId = await pageSession(client, captureSpec);
+    if (!options.noPrompt) await waitForLoginConfirmation(captureSpec, options);
+    else await delay(boundedInteger(options.settleMs, 3_000, 0, 60_000));
+    const cookies = await browserCookies(client);
+    const origins = await originStorage(client, sessionId, captureSpec);
+    return buildWebsiteBrowserProfile(captureSpec, { cookies, origins }, options.now?.() ?? new Date());
+  } finally {
+    if (client) await client.call("Browser.close").catch(() => {});
+    await waitForExit(child, 5_000).catch(() => child.kill("SIGTERM"));
+  }
+}
+
+export function buildWebsiteBrowserProfile(spec, state, capturedAt = new Date()) {
+  const captureSpec = parseCaptureSpec(spec);
+  const allowedHosts = captureSpec.allowedOrigins.map((origin) => new URL(origin).hostname.toLowerCase());
+  const cookies = captureSpec.auth.sendCookies
+    ? array(state.cookies).filter((cookie) => cookieAllowed(cookie.domain, allowedHosts)).map(normalizeCookie)
+    : [];
+  const suffixesByOrigin = new Map();
+  for (const source of captureSpec.auth.headerSources) {
+    const suffixes = suffixesByOrigin.get(source.origin) ?? new Set();
+    suffixes.add(source.keySuffix);
+    suffixesByOrigin.set(source.origin, suffixes);
+  }
+  const origins = array(state.origins).flatMap((entry) => {
+    const origin = String(entry.origin || "");
+    const suffixes = suffixesByOrigin.get(origin);
+    if (!suffixes) return [];
+    const localStorage = array(entry.localStorage).filter((item) => (
+      [...suffixes].some((suffix) => String(item.name || "").endsWith(suffix))
+    )).map((item) => ({ name: String(item.name), value: String(item.value) }));
+    return localStorage.length > 0 ? [{ localStorage, origin }] : [];
+  });
+  return {
+    capturedAt: new Date(capturedAt).toISOString(),
+    connectorId: captureSpec.connectorId,
+    cookies,
+    origins,
+    schemaVersion: WEBSITE_BROWSER_PROFILE_SCHEMA_VERSION
+  };
+}
+
+export function defaultLocalWebsiteProfileDirectory(connectorId, options = {}) {
+  const safeId = requiredConnectorId(connectorId);
+  const profileKey = typeof options.profileKey === "string" && /^bgc_[A-Za-z0-9_-]{43}$/.test(options.profileKey)
+    ? options.profileKey
+    : "default";
+  const currentPlatform = options.platform ?? platform();
+  const homeDirectory = options.home ?? homedir();
+  if (currentPlatform === "darwin") {
+    return join(homeDirectory, "Library", "Application Support", "Fargo AI", "Website Profiles", safeId, profileKey);
+  }
+  if (currentPlatform === "win32") {
+    return join(options.appData ?? process.env.APPDATA ?? join(homeDirectory, "AppData", "Roaming"), "Fargo AI", "Website Profiles", safeId, profileKey);
+  }
+  return join(options.xdgConfigHome ?? process.env.XDG_CONFIG_HOME ?? join(homeDirectory, ".config"), "fargo", "website-profiles", safeId, profileKey);
+}
+
+export function parseCaptureSpec(value) {
+  const source = record(value, "Website Profile capture spec is invalid");
+  if (source.profileSchemaVersion !== WEBSITE_BROWSER_PROFILE_SCHEMA_VERSION) throw new Error("Website Profile schema is not supported");
+  const connectorId = requiredConnectorId(source.connectorId);
+  const allowedOrigins = array(source.allowedOrigins).map(exactHttpsOrigin);
+  if (allowedOrigins.length < 1 || allowedOrigins.length > 12 || new Set(allowedOrigins).size !== allowedOrigins.length) {
+    throw new Error("Website Profile allowed origins are invalid");
+  }
+  const loginUrl = new URL(String(source.loginUrl || ""));
+  if (loginUrl.protocol !== "https:" || !allowedOrigins.includes(loginUrl.origin) || loginUrl.username || loginUrl.password) {
+    throw new Error("Website Profile login URL is invalid");
+  }
+  const auth = record(source.auth, "Website Profile authentication recipe is invalid");
+  const connection = record(source.connection ?? {}, "Website Connection descriptor is invalid");
+  const localProfileKey = typeof connection.connectionId === "string" && /^bgc_[A-Za-z0-9_-]{43}$/.test(connection.connectionId)
+    ? connection.connectionId
+    : undefined;
+  const headerSources = array(auth.headerSources).map((item) => {
+    const binding = record(item, "Website Profile storage selector is invalid");
+    const origin = exactHttpsOrigin(binding.origin);
+    const keySuffix = String(binding.keySuffix || "");
+    if (!allowedOrigins.includes(origin) || !keySuffix || keySuffix.length > 240) {
+      throw new Error("Website Profile storage selector is invalid");
+    }
+    return { keySuffix, origin };
+  });
+  if (headerSources.length > 12) throw new Error("Website Profile storage selector is invalid");
+  if (auth.sendCookies !== true && headerSources.length === 0) throw new Error("Website Profile authentication recipe is empty");
+  return {
+    allowedOrigins,
+    auth: { headerSources, sendCookies: auth.sendCookies === true },
+    connectorId,
+    ...(localProfileKey ? { localProfileKey } : {}),
+    loginUrl: loginUrl.toString(),
+    profileSchemaVersion: WEBSITE_BROWSER_PROFILE_SCHEMA_VERSION
+  };
+}
+
+async function originStorage(client, sessionId, spec) {
+  await client.call("Page.enable", {}, sessionId);
+  await client.call("Runtime.enable", {}, sessionId);
+  const origins = [...new Set(spec.auth.headerSources.map((source) => source.origin))];
+  const result = [];
+  for (const origin of origins) {
+    await client.call("Page.navigate", { url: `${origin}/` }, sessionId);
+    await waitForDocument(client, sessionId, origin);
+    const evaluated = await client.call("Runtime.evaluate", {
+      expression: "Object.entries(window.localStorage).map(([name,value])=>({name,value}))",
+      returnByValue: true
+    }, sessionId);
+    result.push({ localStorage: array(evaluated?.result?.value), origin });
+  }
+  return result;
+}
+
+async function browserCookies(client) {
+  const result = await client.call("Storage.getCookies");
+  return array(result.cookies);
+}
+
+async function pageSession(client, spec) {
+  const targets = await client.call("Target.getTargets");
+  const pages = array(targets.targetInfos).filter((target) => target.type === "page");
+  const page = pages.find((target) => {
+    try {
+      return spec.allowedOrigins.includes(new URL(target.url).origin);
+    } catch {
+      return false;
+    }
+  }) ?? pages[0];
+  if (!page?.targetId) throw new Error("Chrome did not create a page for Website Profile capture");
+  const attached = await client.call("Target.attachToTarget", { flatten: true, targetId: page.targetId });
+  if (!attached.sessionId) throw new Error("Could not attach to the local Chrome page");
+  return attached.sessionId;
+}
+
+async function waitForDocument(client, sessionId, expectedOrigin) {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const result = await client.call("Runtime.evaluate", {
+      expression: "({readyState:document.readyState,url:location.href})",
+      returnByValue: true
+    }, sessionId).catch(() => ({}));
+    const value = result?.result?.value;
+    if (value?.readyState === "complete" && new URL(value.url).origin === expectedOrigin) return;
+    await delay(100);
+  }
+  throw new Error(`Timed out while reading local storage for ${expectedOrigin}`);
+}
+
+async function waitForLoginConfirmation(spec, options) {
+  if (options.waitForLogin) return options.waitForLogin(spec);
+  const input = options.stdin ?? process.stdin;
+  const output = options.stderr ?? process.stderr;
+  if (!input.isTTY) throw new Error("Interactive login requires a TTY; use --no-prompt only for an already authenticated local Profile");
+  output.write(`Fargo opened an isolated local Chrome Profile for ${spec.connectorId}.\nComplete login, then press Enter here to upload only the allowlisted session state.\n`);
+  const prompt = createInterface({ input, output });
+  try {
+    await prompt.question("");
+  } finally {
+    prompt.close();
+  }
+}
+
+async function findChromeExecutable(explicitPath, options) {
+  if (explicitPath) {
+    await access(explicitPath);
+    return resolve(explicitPath);
+  }
+  const currentPlatform = options.platform ?? platform();
+  const candidates = currentPlatform === "darwin"
+    ? [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium"
+      ]
+    : currentPlatform === "win32"
+      ? [
+          join(process.env.PROGRAMFILES ?? "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe"),
+          join(process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe")
+        ]
+      : executableCandidates(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]);
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return candidate;
+    } catch { /* Try the next supported browser path. */ }
+  }
+  throw new Error("Google Chrome or Chromium was not found; pass --chrome-path <path>");
+}
+
+function executableCandidates(names) {
+  return String(process.env.PATH || "").split(delimiter).flatMap((directory) => names.map((name) => join(directory, name)));
+}
+
+async function waitForDevToolsEndpoint(path, child, options) {
+  const timeoutMs = boundedInteger(options.launchTimeoutMs, 15_000, 1_000, 60_000);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (child.exitCode !== null) throw new Error("Chrome exited before Website Profile capture started");
+    try {
+      const [port, browserPath] = (await readFile(path, "utf8")).trim().split(/\r?\n/);
+      if (/^\d+$/.test(port) && browserPath?.startsWith("/devtools/browser/")) {
+        return `ws://127.0.0.1:${port}${browserPath}`;
+      }
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    await delay(100);
+  }
+  throw new Error("Timed out waiting for Chrome DevTools");
+}
+
+function waitForExit(child, timeoutMs) {
+  if (child.exitCode !== null) return Promise.resolve();
+  return new Promise((resolvePromise, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Chrome did not close")), timeoutMs);
+    child.once("exit", () => {
+      clearTimeout(timeout);
+      resolvePromise();
+    });
+  });
+}
+
+class CdpClient {
+  constructor(socket) {
+    this.socket = socket;
+    this.nextId = 1;
+    this.pending = new Map();
+    socket.addEventListener("message", (event) => {
+      const message = JSON.parse(String(event.data));
+      if (!message.id) return;
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      if (message.error) pending.reject(new Error(message.error.message || "Chrome DevTools request failed"));
+      else pending.resolve(message.result ?? {});
+    });
+    socket.addEventListener("close", () => this.rejectPending(new Error("Chrome DevTools connection closed")));
+    socket.addEventListener("error", () => this.rejectPending(new Error("Chrome DevTools connection failed")));
+  }
+
+  static async connect(endpoint) {
+    const socket = new WebSocket(endpoint);
+    await new Promise((resolvePromise, reject) => {
+      socket.addEventListener("open", resolvePromise, { once: true });
+      socket.addEventListener("error", () => reject(new Error("Could not connect to local Chrome DevTools")), { once: true });
+    });
+    return new CdpClient(socket);
+  }
+
+  call(method, params = {}, sessionId) {
+    const id = this.nextId++;
+    return new Promise((resolvePromise, reject) => {
+      this.pending.set(id, { reject, resolve: resolvePromise });
+      this.socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+    });
+  }
+
+  rejectPending(error) {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+}
+
+function normalizeCookie(cookie) {
+  const sameSite = ["Strict", "Lax", "None"].includes(cookie.sameSite) ? cookie.sameSite : undefined;
+  const expires = Number(cookie.expires);
+  return {
+    domain: String(cookie.domain),
+    ...(Number.isFinite(expires) && expires > 0 ? { expires } : {}),
+    httpOnly: cookie.httpOnly === true,
+    name: String(cookie.name),
+    path: String(cookie.path || "/"),
+    ...(sameSite ? { sameSite } : {}),
+    secure: cookie.secure === true,
+    value: String(cookie.value)
+  };
+}
+
+function cookieAllowed(domain, allowedHosts) {
+  const host = String(domain || "").toLowerCase().replace(/^\./, "");
+  return allowedHosts.some((allowed) => host === allowed || host.endsWith(`.${allowed}`));
+}
+
+function exactHttpsOrigin(value) {
+  const url = new URL(String(value || ""));
+  if (url.protocol !== "https:" || url.origin !== value || url.username || url.password) throw new Error("Website Profile origin is invalid");
+  return url.origin;
+}
+
+function requiredConnectorId(value) {
+  const id = String(value || "");
+  if (!/^[a-z][a-z0-9-]{1,62}[a-z0-9]$/.test(id)) throw new Error("Website Connector id is invalid");
+  return id;
+}
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const candidate = value === undefined ? fallback : Number(value);
+  if (!Number.isInteger(candidate) || candidate < minimum || candidate > maximum) throw new Error("Website browser timeout is invalid");
+  return candidate;
+}
+
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function record(value, message) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
+  return value;
+}
+
+function delay(milliseconds) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}

package/src/website-cli.mjs

@@ -0,0 +1,290 @@
+import { createHash, randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { callMcpTool } from "./mcp-client.mjs";
+import { mcpToolPayload } from "./mcp-result.mjs";
+import { captureLocalWebsiteProfile } from "./website-browser-profile.mjs";
+import { parseWebsiteConnectorDefinition } from "./website-connector-definition.mjs";
+
+const WEBSITE_BRIDGE_APP_ID = "website-bridge";
+const WEBSITE_BRIDGE_URL = "https://website-bridge.fargowealth.app";
+
+export async function runWebsiteCommand(args, stdout, store, options = {}) {
+  const action = args[1];
+  if (action === "--help" || action === "-h" || action === "help") {
+    stdout.write(WEBSITE_HELP);
+    return;
+  }
+  if (action === "validate") {
+    const definition = await readDefinition(args);
+    stdout.write(`${JSON.stringify(validationSummary(definition))}\n`);
+    return;
+  }
+  if (action === "release") {
+    const definition = await readDefinition(args);
+    const expectedRevision = optionalInteger(args, "--expected-revision");
+    const result = await callWebsiteBridge(store, "website_connector_release", {
+      definition,
+      ...(expectedRevision === undefined ? {} : { expectedRevision })
+    }, { ...options, confirmation: args.includes("--confirm") });
+    stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+  if (action === "list") {
+    stdout.write(`${JSON.stringify(await callWebsiteBridge(store, "website_connector_list", {}, options))}\n`);
+    return;
+  }
+  if (action === "operations") {
+    stdout.write(`${JSON.stringify(await callWebsiteBridge(store, "website_connector_operations", {
+      connectorId: requiredOption(args, "--connector")
+    }, options))}\n`);
+    return;
+  }
+  if (action === "call") {
+    const write = args.includes("--write");
+    const result = await callWebsiteBridge(store, write ? "website_connector_execute" : "website_connector_read", {
+      connectorId: requiredOption(args, "--connector"),
+      operationId: requiredOption(args, "--operation"),
+      arguments: await readArguments(args)
+    }, { ...options, confirmation: args.includes("--confirm") });
+    stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+  if (action === "connection-status") {
+    stdout.write(`${JSON.stringify(await callWebsiteBridge(store, "website_connection_status", {
+      connectorId: requiredOption(args, "--connector")
+    }, options))}\n`);
+    return;
+  }
+  if (action === "connect" || action === "sync") {
+    const connectorId = requiredOption(args, "--connector");
+    const spec = await callWebsiteBridge(store, "website_connection_profile_spec", { connectorId }, options);
+    const capture = options.captureWebsiteProfile ?? captureLocalWebsiteProfile;
+    const profile = await capture(spec, {
+      chromePath: optionValue(args, "--chrome-path"),
+      noPrompt: args.includes("--no-prompt"),
+      profileDirectory: optionValue(args, "--profile-dir"),
+      settleMs: optionalInteger(args, "--settle-ms"),
+      stderr: options.stderr,
+      stdin: options.stdin
+    });
+    const result = await uploadWebsiteProfile(store, spec, profile, {
+      ...options,
+      connectorId,
+      mode: action === "sync" ? "sync" : "establish"
+    });
+    stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+  if (action === "authorize") {
+    stdout.write(`${JSON.stringify(await callWebsiteBridge(store, "website_connection_authorize", {
+      connectorId: requiredOption(args, "--connector")
+    }, options))}\n`);
+    return;
+  }
+  if (action === "authorize-complete") {
+    stdout.write(`${JSON.stringify(await callWebsiteBridge(store, "website_connection_authorize_complete", {
+      connectorId: requiredOption(args, "--connector")
+    }, options))}\n`);
+    return;
+  }
+  if (action === "binding") {
+    stdout.write(`${JSON.stringify({
+      appId: WEBSITE_BRIDGE_APP_ID,
+      manifestVersion: "fargo.app-mcp/v1",
+      requiresCurrentUserDelegation: true,
+      authority: { mode: "invoking_user" },
+      allowedToolNames: [
+        "website_connector_list",
+        "website_connector_operations",
+        "website_connector_read",
+        "website_connector_execute",
+        "website_connection_status"
+      ]
+    }, null, 2)}\n`);
+    return;
+  }
+  throw new Error(WEBSITE_USAGE);
+}
+
+async function callWebsiteBridge(store, toolName, toolArguments, options) {
+  return mcpToolPayload(await callMcpTool(store, "app_mcp_tool_call", {
+    appId: WEBSITE_BRIDGE_APP_ID,
+    toolName,
+    arguments: toolArguments,
+    ...(options.confirmation === true ? { confirmation: true } : {})
+  }, options));
+}
+
+async function readDefinition(args) {
+  const path = resolve(requiredOption(args, "--file"));
+  let value;
+  try {
+    value = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error("Website Connector definition must be valid JSON");
+    throw error;
+  }
+  return parseWebsiteConnectorDefinition(value);
+}
+
+async function readArguments(args) {
+  const inline = optionValue(args, "--args");
+  const file = optionValue(args, "--args-file");
+  if (inline !== undefined && file !== undefined) throw new Error("Use only one of --args or --args-file");
+  const text = file === undefined ? inline ?? "{}" : await readFile(resolve(file), "utf8");
+  try {
+    const value = JSON.parse(text);
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid");
+    return value;
+  } catch {
+    throw new Error("Website operation arguments must be a JSON object");
+  }
+}
+
+function validationSummary(definition) {
+  const canonical = JSON.stringify(definition);
+  return {
+    valid: true,
+    schemaVersion: definition.schemaVersion,
+    connectorId: definition.connectorId,
+    displayName: definition.displayName,
+    operationCount: definition.operations.length,
+    requiresConnection: definition.operations.some((operation) => operation.requiresConnection),
+    sha256: createHash("sha256").update(canonical).digest("hex")
+  };
+}
+
+function optionalInteger(args, name) {
+  const raw = optionValue(args, name);
+  if (raw === undefined) return undefined;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) throw new Error(`${name} must be a non-negative integer`);
+  return value;
+}
+
+function requiredOption(args, name) {
+  const value = optionValue(args, name)?.trim();
+  if (!value || value.startsWith("--")) throw new Error(`Missing required option ${name}`);
+  return value;
+}
+
+function optionValue(args, name) {
+  const inline = args.find((value) => value.startsWith(`${name}=`));
+  if (inline) return inline.slice(name.length + 1);
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+export async function uploadWebsiteProfile(store, spec, profile, options) {
+  assertWebsiteProfile(profile, options.connectorId);
+  const body = JSON.stringify(profile);
+  const bodyBytes = Buffer.byteLength(body, "utf8");
+  if (bodyBytes > 512_000) throw new Error("Website Profile exceeds the 512 KB upload limit");
+  const uploadSecret = randomBytes(32).toString("base64url");
+  const mode = options.mode === "sync" ? "sync" : "establish";
+  const currentVersion = Number(spec?.connection?.profileVersion ?? 0);
+  if (
+    mode === "sync"
+    && (
+      !Number.isInteger(currentVersion)
+      || currentVersion < 1
+      || !["active", "needs_reauth"].includes(spec?.connection?.state)
+    )
+  ) {
+    throw new Error("Website Connection must already exist before it can be synchronized");
+  }
+  const capability = await callWebsiteBridge(store, "website_connection_import_begin", {
+    connectorId: options.connectorId,
+    mode,
+    profileSha256: createHash("sha256").update(body).digest("hex"),
+    uploadSecretSha256: createHash("sha256").update(uploadSecret).digest("hex"),
+    ...(mode === "sync" ? { expectedProfileVersion: currentVersion } : {})
+  }, options);
+  if (
+    capability?.method !== "POST"
+    || !Number.isInteger(capability?.maxBytes)
+    || capability.maxBytes < bodyBytes
+    || capability.maxBytes > 512_000
+    || !Number.isFinite(Date.parse(capability?.expiresAt))
+    || Date.parse(capability.expiresAt) <= Date.now()
+  ) throw new Error("Website Profile upload capability is invalid");
+  const uploadUrl = validatedUploadUrl(capability?.uploadUrl, options);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const response = await fetchImpl(uploadUrl, {
+    body,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-Fargo-Profile-Upload-Secret": uploadSecret
+    },
+    method: "POST",
+    redirect: "error"
+  });
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error(`Website Profile upload failed (${response.status})`);
+  }
+  if (!response.ok) throw new Error(payload?.error || `Website Profile upload failed (${response.status})`);
+  return payload;
+}
+
+function assertWebsiteProfile(profile, connectorId) {
+  if (
+    !profile
+    || typeof profile !== "object"
+    || Array.isArray(profile)
+    || profile.schemaVersion !== "fargo.browser-profile/v1"
+    || profile.connectorId !== connectorId
+    || !Number.isFinite(Date.parse(profile.capturedAt))
+    || !Array.isArray(profile.cookies)
+    || !Array.isArray(profile.origins)
+  ) throw new Error("Local Website Profile is invalid");
+}
+
+function validatedUploadUrl(value, options) {
+  const expectedOrigin = new URL(options.websiteBridgeUrl ?? process.env.FARGO_WEBSITE_BRIDGE_URL ?? WEBSITE_BRIDGE_URL).origin;
+  let url;
+  try {
+    url = new URL(String(value || ""));
+  } catch {
+    throw new Error("Website Profile upload capability is invalid");
+  }
+  if (
+    url.protocol !== "https:"
+    || url.origin !== expectedOrigin
+    || !/^\/v1\/website\/profile-imports\/wpi_[0-9a-f-]{36}$/.test(url.pathname)
+    || url.search
+    || url.hash
+    || url.username
+    || url.password
+  ) throw new Error("Website Profile upload capability is invalid");
+  return url.toString();
+}
+
+export const WEBSITE_USAGE = "Usage: fargo website validate|release|list|operations|call|connect|sync|connection-status|authorize|authorize-complete|binding";
+
+export const WEBSITE_HELP = `Usage: fargo website <command> [options]
+
+Connector authoring:
+  validate --file <path>
+  release --file <path> [--expected-revision <n>] --confirm
+  list
+  operations --connector <id>
+
+Connection and execution:
+  connect --connector <id> [--chrome-path <path>] [--profile-dir <path>]
+  sync --connector <id> [--no-prompt] [--settle-ms <n>]
+  connection-status --connector <id>
+  call --connector <id> --operation <id> [--args <json> | --args-file <path>]
+  call --connector <id> --operation <id> --write [--confirm]
+
+Cloud login fallback:
+  authorize --connector <id>
+  authorize-complete --connector <id>
+
+Teammate:
+  binding
+`;

package/src/website-connector-definition.d.mts

@@ -0,0 +1,58 @@
+export type WebsiteConnectorInputSchema = {
+  additionalProperties: false;
+  properties: Record<string, {
+    enum?: Array<string | number | boolean>;
+    maxLength?: number;
+    type: "string" | "number" | "integer" | "boolean";
+  }>;
+  required: string[];
+  type: "object";
+};
+
+export type WebsiteConnectorAuth =
+  | { kind: "none" }
+  | {
+      kind: "browser_storage";
+      sendCookies: boolean;
+      headerSources: Array<{ keySuffix: string; name: string; origin: string; prefix?: string }>;
+    };
+
+export type WebsiteConnectorOperation = {
+  operationId: string;
+  description: string;
+  readOnly: boolean;
+  requiresConnection: boolean;
+  riskLevel: "low" | "medium" | "high" | "critical";
+  inputSchema: WebsiteConnectorInputSchema;
+  request: {
+    origin: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    body?: unknown;
+  };
+};
+
+export type WebsiteConnectorDefinition = {
+  schemaVersion: "fargo.website-connector/v1";
+  connectorId: string;
+  displayName: string;
+  allowedOrigins: string[];
+  loginUrl?: string;
+  auth: WebsiteConnectorAuth;
+  operations: WebsiteConnectorOperation[];
+};
+
+export const WEBSITE_CONNECTOR_SCHEMA_VERSION: "fargo.website-connector/v1";
+export class WebsiteConnectorDefinitionError extends Error {
+  code: string;
+  path: string;
+}
+export function parseWebsiteConnectorDefinition(value: unknown): WebsiteConnectorDefinition;
+export function connectorToolName(connectorId: string, operationId: string): string;
+export function renderWebsiteOperation(definition: unknown, operationId: string, rawArguments: unknown): {
+  definition: WebsiteConnectorDefinition;
+  operation: WebsiteConnectorOperation;
+  request: { body?: unknown; headers: Record<string, string>; method: string; url: string };
+};

package/src/website-connector-definition.mjs

@@ -0,0 +1,339 @@
+const CONNECTOR_ID = /^[a-z][a-z0-9-]{1,62}[a-z0-9]$/;
+const OPERATION_ID = /^[a-z][a-z0-9_]{1,62}[a-z0-9]$/;
+const TEMPLATE_ARGUMENT = /\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g;
+const FORBIDDEN_HEADERS = new Set([
+  "connection",
+  "content-length",
+  "cookie",
+  "host",
+  "proxy-authorization",
+  "transfer-encoding",
+  "upgrade"
+]);
+
+export const WEBSITE_CONNECTOR_SCHEMA_VERSION = "fargo.website-connector/v1";
+
+export class WebsiteConnectorDefinitionError extends Error {
+  constructor(code, path = "") {
+    super(path ? `${code}:${path}` : code);
+    this.name = "WebsiteConnectorDefinitionError";
+    this.code = code;
+    this.path = path;
+  }
+}
+
+export function parseWebsiteConnectorDefinition(value) {
+  const source = record(value, "website_connector_definition_invalid", "/");
+  equal(source.schemaVersion, WEBSITE_CONNECTOR_SCHEMA_VERSION, "website_connector_schema_version_invalid", "/schemaVersion");
+  const connectorId = requiredText(source.connectorId, 64, "website_connector_id_invalid", "/connectorId");
+  if (!CONNECTOR_ID.test(connectorId)) fail("website_connector_id_invalid", "/connectorId");
+  const displayName = requiredText(source.displayName, 120, "website_connector_display_name_invalid", "/displayName");
+  const allowedOrigins = uniqueArray(source.allowedOrigins, 1, 12, "/allowedOrigins").map((origin, index) => (
+    exactHttpsOrigin(origin, "website_connector_origin_invalid", `/allowedOrigins/${index}`)
+  ));
+  const loginUrl = optionalHttpsUrl(source.loginUrl, allowedOrigins, "/loginUrl");
+  const auth = parseAuthRecipe(source.auth, allowedOrigins);
+  if (auth.kind === "browser_storage" && !loginUrl) fail("website_connector_login_url_required", "/loginUrl");
+  const operations = uniqueArray(source.operations, 1, 80, "/operations").map((operation, index) => (
+    parseOperation(operation, allowedOrigins, index)
+  ));
+  const operationIds = new Set();
+  for (const operation of operations) {
+    if (operationIds.has(operation.operationId)) fail("website_operation_id_duplicate", `/operations/${operation.operationId}`);
+    if (operation.requiresConnection && auth.kind !== "browser_storage") {
+      fail("website_operation_connection_auth_required", `/operations/${operation.operationId}/requiresConnection`);
+    }
+    operationIds.add(operation.operationId);
+  }
+  return {
+    schemaVersion: WEBSITE_CONNECTOR_SCHEMA_VERSION,
+    connectorId,
+    displayName,
+    allowedOrigins,
+    ...(loginUrl ? { loginUrl } : {}),
+    auth,
+    operations
+  };
+}
+
+export function connectorToolName(connectorId, operationId) {
+  const left = String(connectorId || "").replaceAll("-", "_");
+  return `${left}_${operationId}`;
+}
+
+export function renderWebsiteOperation(definition, operationId, rawArguments) {
+  const parsed = parseWebsiteConnectorDefinition(definition);
+  const operation = parsed.operations.find((candidate) => candidate.operationId === operationId);
+  if (!operation) fail("website_operation_not_found", "/operationId");
+  const args = record(rawArguments ?? {}, "website_operation_arguments_invalid", "/arguments");
+  validateArguments(args, operation.inputSchema);
+  const path = renderString(operation.request.path, args, "/request/path");
+  const url = new URL(path, `${operation.request.origin}/`);
+  if (url.origin !== operation.request.origin) fail("website_operation_origin_escape", "/request/path");
+  for (const [name, argumentName] of Object.entries(operation.request.query)) {
+    const value = args[argumentName];
+    if (value !== undefined && value !== null) url.searchParams.set(name, scalarText(value, `/arguments/${argumentName}`));
+  }
+  const body = operation.request.body === undefined
+    ? undefined
+    : renderBody(operation.request.body, args, "/request/body");
+  return {
+    definition: parsed,
+    operation,
+    request: {
+      body,
+      headers: { ...operation.request.headers },
+      method: operation.request.method,
+      url: url.toString()
+    }
+  };
+}
+
+function parseAuthRecipe(value, allowedOrigins) {
+  const source = value === undefined ? { kind: "none" } : record(value, "website_auth_recipe_invalid", "/auth");
+  if (source.kind === "none") return { kind: "none" };
+  equal(source.kind, "browser_storage", "website_auth_recipe_invalid", "/auth/kind");
+  const sendCookies = source.sendCookies === true;
+  const headerSources = source.headerSources === undefined
+    ? []
+    : uniqueArray(source.headerSources, 0, 12, "/auth/headerSources").map((item, index) => {
+        const binding = record(item, "website_auth_header_source_invalid", `/auth/headerSources/${index}`);
+        const name = headerName(binding.name, `/auth/headerSources/${index}/name`, true);
+        const origin = exactHttpsOrigin(binding.origin, "website_auth_header_source_invalid", `/auth/headerSources/${index}/origin`);
+        if (!allowedOrigins.includes(origin)) fail("website_auth_origin_not_allowed", `/auth/headerSources/${index}/origin`);
+        const keySuffix = requiredText(binding.keySuffix, 240, "website_auth_header_source_invalid", `/auth/headerSources/${index}/keySuffix`);
+        const prefix = optionalHeaderPrefix(binding.prefix, `/auth/headerSources/${index}/prefix`);
+        return { keySuffix, name, origin, ...(prefix ? { prefix } : {}) };
+      });
+  if (!sendCookies && headerSources.length === 0) fail("website_auth_recipe_empty", "/auth");
+  return { kind: "browser_storage", sendCookies, headerSources };
+}
+
+function parseOperation(value, allowedOrigins, index) {
+  const path = `/operations/${index}`;
+  const source = record(value, "website_operation_invalid", path);
+  const operationId = requiredText(source.operationId, 64, "website_operation_id_invalid", `${path}/operationId`);
+  if (!OPERATION_ID.test(operationId)) fail("website_operation_id_invalid", `${path}/operationId`);
+  const description = requiredText(source.description, 500, "website_operation_description_invalid", `${path}/description`);
+  const readOnly = source.readOnly === true;
+  const requiresConnection = source.requiresConnection === true;
+  const riskLevel = optionalEnum(source.riskLevel, ["low", "medium", "high", "critical"], readOnly ? "low" : "medium", `${path}/riskLevel`);
+  const inputSchema = parseInputSchema(source.inputSchema, `${path}/inputSchema`);
+  const requestSource = record(source.request, "website_operation_request_invalid", `${path}/request`);
+  const origin = exactHttpsOrigin(requestSource.origin, "website_operation_origin_invalid", `${path}/request/origin`);
+  if (!allowedOrigins.includes(origin)) fail("website_operation_origin_not_allowed", `${path}/request/origin`);
+  const method = optionalEnum(requestSource.method, ["GET", "POST", "PUT", "PATCH", "DELETE"], "GET", `${path}/request/method`);
+  if (readOnly && method !== "GET") fail("website_operation_read_only_method_invalid", `${path}/request/method`);
+  const requestPath = requiredText(requestSource.path, 2_000, "website_operation_path_invalid", `${path}/request/path`);
+  if (!requestPath.startsWith("/") || requestPath.startsWith("//") || requestPath.includes("\\")) {
+    fail("website_operation_path_invalid", `${path}/request/path`);
+  }
+  const pathArguments = [...requestPath.matchAll(TEMPLATE_ARGUMENT)].map((match) => match[1]);
+  const properties = record(inputSchema.properties ?? {}, "website_operation_input_schema_invalid", `${path}/inputSchema/properties`);
+  for (const argument of pathArguments) {
+    if (!Object.hasOwn(properties, argument)) fail("website_operation_template_argument_unknown", `${path}/request/path`);
+  }
+  const query = requestSource.query === undefined
+    ? {}
+    : Object.fromEntries(Object.entries(record(requestSource.query, "website_operation_query_invalid", `${path}/request/query`)).map(([name, argument]) => {
+        if (!/^[A-Za-z0-9_.~-]{1,120}$/.test(name)) fail("website_operation_query_name_invalid", `${path}/request/query/${name}`);
+        const argumentName = requiredText(argument, 120, "website_operation_query_argument_invalid", `${path}/request/query/${name}`);
+        if (!Object.hasOwn(properties, argumentName)) fail("website_operation_query_argument_unknown", `${path}/request/query/${name}`);
+        return [name, argumentName];
+      }));
+  const headers = requestSource.headers === undefined
+    ? {}
+    : Object.fromEntries(Object.entries(record(requestSource.headers, "website_operation_headers_invalid", `${path}/request/headers`)).map(([name, headerValue]) => {
+        const normalized = requiredText(headerValue, 500, "website_operation_header_value_invalid", `${path}/request/headers/${name}`);
+        if (/[\r\n\0]/.test(normalized)) fail("website_operation_header_value_invalid", `${path}/request/headers/${name}`);
+        return [headerName(name, `${path}/request/headers/${name}`, false), normalized];
+      }));
+  const body = requestSource.body;
+  if (body !== undefined && method === "GET") fail("website_operation_get_body_invalid", `${path}/request/body`);
+  if (body !== undefined) validateBodyTemplate(body, properties, `${path}/request/body`);
+  return {
+    operationId,
+    description,
+    readOnly,
+    requiresConnection,
+    riskLevel,
+    inputSchema,
+    request: {
+      origin,
+      method,
+      path: requestPath,
+      query,
+      headers,
+      ...(body === undefined ? {} : { body })
+    }
+  };
+}
+
+function optionalHeaderPrefix(value, path) {
+  if (value === undefined || value === null || value === "") return "";
+  if (typeof value !== "string" || value.length > 80 || /[\r\n\0]/.test(value)) {
+    fail("website_auth_header_source_invalid", path);
+  }
+  return value;
+}
+
+function parseInputSchema(value, path) {
+  const source = value === undefined
+    ? { additionalProperties: false, properties: {}, type: "object" }
+    : record(value, "website_operation_input_schema_invalid", path);
+  equal(source.type, "object", "website_operation_input_schema_invalid", `${path}/type`);
+  if (source.additionalProperties !== false) fail("website_operation_input_schema_open", `${path}/additionalProperties`);
+  const properties = record(source.properties ?? {}, "website_operation_input_schema_invalid", `${path}/properties`);
+  const normalizedProperties = {};
+  for (const [name, candidate] of Object.entries(properties)) {
+    if (!/^[A-Za-z][A-Za-z0-9_]{0,119}$/.test(name)) fail("website_operation_input_name_invalid", `${path}/properties/${name}`);
+    const property = record(candidate, "website_operation_input_property_invalid", `${path}/properties/${name}`);
+    const type = optionalEnum(property.type, ["string", "number", "integer", "boolean"], "string", `${path}/properties/${name}/type`);
+    normalizedProperties[name] = {
+      type,
+      ...(typeof property.maxLength === "number" ? { maxLength: boundedInteger(property.maxLength, 1, 20_000, `${path}/properties/${name}/maxLength`) } : {}),
+      ...(Array.isArray(property.enum) ? { enum: property.enum.map((item) => scalar(item, `${path}/properties/${name}/enum`)) } : {})
+    };
+  }
+  const required = source.required === undefined ? [] : uniqueArray(source.required, 0, Object.keys(normalizedProperties).length, `${path}/required`).map(String);
+  for (const name of required) if (!Object.hasOwn(normalizedProperties, name)) fail("website_operation_required_unknown", `${path}/required`);
+  return { additionalProperties: false, properties: normalizedProperties, required, type: "object" };
+}
+
+function validateArguments(args, schema) {
+  for (const required of schema.required) if (!Object.hasOwn(args, required)) fail("website_operation_argument_required", `/arguments/${required}`);
+  for (const [name, value] of Object.entries(args)) {
+    const property = schema.properties[name];
+    if (!property) fail("website_operation_argument_unknown", `/arguments/${name}`);
+    if (property.type === "string" && typeof value !== "string") fail("website_operation_argument_type_invalid", `/arguments/${name}`);
+    if (property.type === "number" && (typeof value !== "number" || !Number.isFinite(value))) fail("website_operation_argument_type_invalid", `/arguments/${name}`);
+    if (property.type === "integer" && !Number.isInteger(value)) fail("website_operation_argument_type_invalid", `/arguments/${name}`);
+    if (property.type === "boolean" && typeof value !== "boolean") fail("website_operation_argument_type_invalid", `/arguments/${name}`);
+    if (property.maxLength && typeof value === "string" && value.length > property.maxLength) fail("website_operation_argument_too_long", `/arguments/${name}`);
+    if (property.enum && !property.enum.some((candidate) => Object.is(candidate, value))) fail("website_operation_argument_enum_invalid", `/arguments/${name}`);
+  }
+}
+
+function validateBodyTemplate(value, properties, path) {
+  if (typeof value === "string") {
+    if (value.startsWith("$") && !Object.hasOwn(properties, value.slice(1))) fail("website_operation_body_argument_unknown", path);
+    return;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") return;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateBodyTemplate(item, properties, `${path}/${index}`));
+    return;
+  }
+  const source = record(value, "website_operation_body_invalid", path);
+  for (const [name, item] of Object.entries(source)) validateBodyTemplate(item, properties, `${path}/${name}`);
+}
+
+function renderBody(value, args, path) {
+  if (typeof value === "string") {
+    if (value.startsWith("$")) return args[value.slice(1)];
+    return renderString(value, args, path);
+  }
+  if (Array.isArray(value)) return value.map((item, index) => renderBody(item, args, `${path}/${index}`));
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([name, item]) => [name, renderBody(item, args, `${path}/${name}`)]));
+  return value;
+}
+
+function renderString(value, args, path) {
+  return String(value).replace(TEMPLATE_ARGUMENT, (_match, name) => encodeURIComponent(scalarText(args[name], `/arguments/${name || path}`)));
+}
+
+function scalarText(value, path) {
+  scalar(value, path);
+  return String(value);
+}
+
+function scalar(value, path) {
+  if (!["string", "number", "boolean"].includes(typeof value) || (typeof value === "number" && !Number.isFinite(value))) {
+    fail("website_operation_argument_scalar_required", path);
+  }
+  return value;
+}
+
+function headerName(value, path, allowAuthorization) {
+  const name = requiredText(value, 100, "website_operation_header_name_invalid", path);
+  const normalized = name.toLowerCase();
+  if (!/^[A-Za-z][A-Za-z0-9-]*$/.test(name) || FORBIDDEN_HEADERS.has(normalized) || (!allowAuthorization && normalized === "authorization")) {
+    fail("website_operation_header_name_invalid", path);
+  }
+  return name;
+}
+
+function exactHttpsOrigin(value, code, path) {
+  const text = requiredText(value, 500, code, path);
+  try {
+    const url = new URL(text);
+    if (url.protocol !== "https:" || url.origin !== text || url.username || url.password || !publicHostname(url.hostname)) fail(code, path);
+    return url.origin;
+  } catch (error) {
+    if (error instanceof WebsiteConnectorDefinitionError) throw error;
+    fail(code, path);
+  }
+}
+
+function publicHostname(value) {
+  const hostname = String(value).toLowerCase().replace(/^\[|\]$/g, "");
+  if (!hostname.includes(".") || /^[0-9.]+$/.test(hostname) || hostname.includes(":")) return false;
+  return !hostname.endsWith(".localhost")
+    && !hostname.endsWith(".local")
+    && !hostname.endsWith(".internal")
+    && hostname !== "metadata.google.internal";
+}
+
+function optionalHttpsUrl(value, allowedOrigins, path) {
+  if (value === undefined || value === null || value === "") return undefined;
+  try {
+    const url = new URL(requiredText(value, 2_000, "website_connector_login_url_invalid", path));
+    if (url.protocol !== "https:" || !allowedOrigins.includes(url.origin) || url.username || url.password || url.hash) fail("website_connector_login_url_invalid", path);
+    return url.toString();
+  } catch (error) {
+    if (error instanceof WebsiteConnectorDefinitionError) throw error;
+    fail("website_connector_login_url_invalid", path);
+  }
+}
+
+function record(value, code, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail(code, path);
+  return value;
+}
+
+function uniqueArray(value, min, max, path) {
+  if (!Array.isArray(value) || value.length < min || value.length > max) fail("website_connector_array_invalid", path);
+  const serialized = value.map((item) => typeof item === "string" ? item : JSON.stringify(item));
+  if (new Set(serialized).size !== serialized.length) fail("website_connector_array_duplicate", path);
+  return value;
+}
+
+function requiredText(value, max, code, path) {
+  const text = typeof value === "string" ? value.trim() : "";
+  if (!text || text.length > max) fail(code, path);
+  return text;
+}
+
+function optionalText(value, max, code, path) {
+  if (value === undefined || value === null || value === "") return undefined;
+  return requiredText(value, max, code, path);
+}
+
+function optionalEnum(value, allowed, fallback, path) {
+  const candidate = value === undefined ? fallback : value;
+  if (!allowed.includes(candidate)) fail("website_connector_enum_invalid", path);
+  return candidate;
+}
+
+function boundedInteger(value, min, max, path) {
+  if (!Number.isInteger(value) || value < min || value > max) fail("website_connector_integer_invalid", path);
+  return value;
+}
+
+function equal(actual, expected, code, path) {
+  if (actual !== expected) fail(code, path);
+}
+
+function fail(code, path) {
+  throw new WebsiteConnectorDefinitionError(code, path);
+}