@vornrun/connector-sdk 0.7.0-beta.17 → 0.7.0-beta.19

package/README.md

@@ -202,6 +202,25 @@ Two rules make a pull trigger reliable, and the SDK enforces both:
    it. Use `>=` when filtering on `since` and sort ascending; returning a few
    items again is free, because the SDK drops anything already delivered.
 
+## Act through a signed-in window
+
+A service with no API to key can still be reached as the person using it. Declare the `browser` rung with the page to sign in on, the origins the connector may act on, and a check that answers 2xx only while someone is signed in:
+
+```ts
+auth: {
+  rung: 'browser',
+  browser: {
+    signInUrl: 'https://example.com/login',
+    origins: ['https://example.com', 'https://*.example.com'],
+    check: { url: 'https://example.com/api/me', identity: ['name', 'handle'] }
+  }
+}
+```
+
+Vorn opens a window on a browser profile that belongs to one connection, and the person signs in there. The connector's code then gets `ctx.session.fetch` beside `ctx.fetch`. A call through `ctx.session.fetch` runs inside that signed-in window as a same-origin request, so the service sees its own page asking and no cookie reaches the connector. Calls outside `origins` are refused. `ctx.fetch` stays a plain fetch for public reads, such as a feed, which work before anyone signs in. A `browser` connector's declared `request` actions go through the window.
+
+`--mock` serves signed-in calls from the same routes as every other call. A `--live` run from a terminal has no window, so it skips them.
+
 ## Dedupe strategies
 
 `dedupe` tells the SDK how to recognize new items, and it then owns the cursor

package/dist/{check-Cv6UNBA4.d.ts → check-62s2GvcO.d.ts}

@@ -73,6 +73,8 @@ interface PollContext {
     now(): string;
     /** Fetch with the SDK's retry and backoff applied. A poll is always a read. */
     fetch: typeof fetch;
+    /** Present only when the connector signs in through a Vorn window. */
+    session?: SessionContext;
 }
 interface PollOutcome {
     items: ConnectorItem[];
@@ -114,6 +116,8 @@ interface FetchContext {
     now(): string;
     /** Fetch with the SDK's retry and backoff applied. A fetch is always a read. */
     fetch: typeof fetch;
+    /** Present only when the connector signs in through a Vorn window. */
+    session?: SessionContext;
 }
 /**
  * What an upstream state should become when an item is imported as a task.
@@ -227,6 +231,8 @@ interface ActionContext {
      * same resilience a declared request does, and tests can replace it.
      */
     fetch: typeof fetch;
+    /** Present only when the connector signs in through a Vorn window. */
+    session?: SessionContext;
 }
 /**
  * One step of reshaping a response.
@@ -369,9 +375,27 @@ interface PreflightResult {
  * `none` needs nothing — installing it is the whole setup. `cli` borrows a
  * login that already works on the machine, which is the rung to prefer
  * whenever a mature tool is signed in anyway. `key` asks for a credential.
+ * `browser` signs in through a Vorn window for a service with no API to key.
  * `oauth` is declared but not yet carried by the host.
  */
-type AuthRung = 'none' | 'cli' | 'key' | 'oauth';
+type AuthRung = 'none' | 'cli' | 'key' | 'browser' | 'oauth';
+/** How a `browser` connector signs in, and the only origins its calls may reach. */
+interface BrowserSignIn {
+    /** The page the Vorn window opens for signing in. */
+    signInUrl: string;
+    /** `https://host` or `https://*.host`; the sign-in page and the check must sit inside them. */
+    origins: string[];
+    /** Answers 2xx only when signed in; `identity` names the fields of its JSON that say who. */
+    check: {
+        url: string;
+        identity: string[];
+    };
+}
+/** The signed-in window, offered to a `browser` connector's code. */
+interface SessionContext {
+    /** Runs the request inside the connection's signed-in window; cookies never reach the connector. */
+    fetch: typeof fetch;
+}
 /**
  * What a connector needs before it can talk to anything.
  *
@@ -408,6 +432,8 @@ interface ConnectorAuth {
     };
     /** Config field keys holding the credential. Required for `key`. */
     keys?: string[];
+    /** Required for `browser`. */
+    browser?: BrowserSignIn;
 }
 /** What an options set is given to work out its choices. */
 interface OptionsContext {
@@ -415,6 +441,8 @@ interface OptionsContext {
     now(): string;
     /** Fetch with the SDK's retry and backoff applied. Listing choices is a read. */
     fetch: typeof fetch;
+    /** Present only when the connector signs in through a Vorn window. */
+    session?: SessionContext;
 }
 /**
  * Answers the question "what can this field be?" against a live connection.
@@ -725,6 +753,10 @@ interface RunPollOptions {
     now?: () => string;
     /** Replaced by the harness and by tests; defaults to the global fetch. */
     fetchImpl?: typeof fetch;
+    /** Replaced by the harness and by tests; defaults to the signed-in window Vorn serves. */
+    sessionFetchImpl?: typeof fetch;
+    /** The key Vorn gave this tool call, carried on each request through the window. */
+    sessionCall?: string;
     retry?: RetryPolicy;
     /** Replaced in tests so backoff costs no real time. */
     sleep?: (ms: number) => Promise<void>;
@@ -747,6 +779,10 @@ interface RunActionOptions {
     now?: () => string;
     /** Replaced by the harness and by tests; defaults to the global fetch. */
     fetchImpl?: typeof fetch;
+    /** Replaced by the harness and by tests; defaults to the signed-in window Vorn serves. */
+    sessionFetchImpl?: typeof fetch;
+    /** The key Vorn gave this tool call, carried on each request through the window. */
+    sessionCall?: string;
     retry?: RetryPolicy;
     /** Replaced in tests so backoff costs no real time. */
     sleep?: (ms: number) => Promise<void>;
@@ -902,6 +938,8 @@ interface HarnessOptions {
     now?: () => string;
     /** Answer the connector's calls from the test rather than the network. */
     fetchImpl?: typeof fetch;
+    /** Answer its signed-in calls; defaults to `fetchImpl`, so one stub serves both. */
+    sessionFetchImpl?: typeof fetch;
     /** Fake clock for backoff, so a retry test costs no real time. */
     sleep?: (ms: number) => Promise<void>;
 }
@@ -1096,4 +1134,4 @@ declare function runConformance(connector: Connector, options?: CheckOptions): P
 /** Render findings for a terminal. Returns an empty string when all clear. */
 declare function formatFindings(findings: CheckFinding[]): string;
 
-export { MAX_PACK_BYTES as $, type ActionRequest as A, type BundleRequest as B, type CheckFinding as C, type ConnectorIcon as D, type ExtensionPermission as E, type ConnectorKind as F, type ConnectorManifest as G, type ConnectorVerification as H, type DedupeStrategy as I, type DefaultWorkflow as J, type ExtensionAgent as K, type ExtensionContext as L, type ExtensionContributions as M, type NormalizedItem as N, type ExtensionPlatform as O, type PollContext as P, type ExtensionUsage as Q, type ExtensionUsageWindow as R, type FetchContext as S, type TriggerDefinition as T, type FooterContribution as U, type FooterItem as V, type HarnessOptions as W, type LinkContext as X, type LinkHandled as Y, type LinkHandlerContribution as Z, MANIFEST_TOOL as _, type BundleOutput as a, MAX_POLL_PAGES as a0, type ManifestContributions as a1, type MockCall as a2, type MockHostAnswers as a3, type MockHostRun as a4, type MockRoute as a5, MockRouteMissError as a6, type MockRun as a7, OPTIONS_TOOL as a8, type OptionsContext as a9, pollToolName as aA, readNearestPackageJson as aB, resilientFetch as aC, retryAfterMs as aD, runAction as aE, runConformance as aF, runOptions as aG, runPoll as aH, withMockHttp as aI, type OptionsLoader as aa, PREFLIGHT_TOOL as ab, type PaginationStrategy as ac, type PaneContribution as ad, type PollPage as ae, type PreflightResult as af, type ResilientFetchOptions as ag, type RetryPolicy as ah, type RunActionOptions as ai, type RunPollOptions as aj, type StatusSuggestion as ak, backoffMs as al, bundleDependencyFindings as am, bundledRequireFindings as an, checkConnector as ao, connectionSetup as ap, connectorManifest as aq, createConnectorHarness as ar, drainPoll as as, esbuildBundle as at, escapedMockHttp as au, footerToolName as av, formatFindings as aw, handlerToolName as ax, lifecycleScriptFindings as ay, mockExtensionHost as az, type ExtensionHostMethod as b, type ConnectorDefinition as c, type Connector as d, type ExtensionDefinition as e, type ConnectorConfig as f, type ExtensionHost as g, type PollOutcome as h, type ConnectorItem as i, type PostReceiveOp as j, type ActionContext as k, type ActionDefinition as l, type ActionInputField as m, type ActionInputOption as n, type ActionInputType as o, type ActionOutputField as p, type ActivationPredicate as q, type AuthRung as r, CHECK_OWNERS as s, type CheckCode as t, type CheckOptions as u, type ConformanceRun as v, type ConnectionSetup as w, type ConnectorAuth as x, type ConnectorConfigField as y, type ConnectorHarness as z };
+export { MANIFEST_TOOL as $, type ActionRequest as A, type BundleRequest as B, type CheckFinding as C, type ConnectorHarness as D, type ExtensionPermission as E, type ConnectorIcon as F, type ConnectorKind as G, type ConnectorManifest as H, type ConnectorVerification as I, type DedupeStrategy as J, type DefaultWorkflow as K, type ExtensionAgent as L, type ExtensionContext as M, type NormalizedItem as N, type ExtensionContributions as O, type PollContext as P, type ExtensionPlatform as Q, type ExtensionUsage as R, type ExtensionUsageWindow as S, type TriggerDefinition as T, type FetchContext as U, type FooterContribution as V, type FooterItem as W, type HarnessOptions as X, type LinkContext as Y, type LinkHandled as Z, type LinkHandlerContribution as _, type BundleOutput as a, MAX_PACK_BYTES as a0, MAX_POLL_PAGES as a1, type ManifestContributions as a2, type MockCall as a3, type MockHostAnswers as a4, type MockHostRun as a5, type MockRoute as a6, MockRouteMissError as a7, type MockRun as a8, OPTIONS_TOOL as a9, lifecycleScriptFindings as aA, mockExtensionHost as aB, pollToolName as aC, readNearestPackageJson as aD, resilientFetch as aE, retryAfterMs as aF, runAction as aG, runConformance as aH, runOptions as aI, runPoll as aJ, withMockHttp as aK, type OptionsContext as aa, type OptionsLoader as ab, PREFLIGHT_TOOL as ac, type PaginationStrategy as ad, type PaneContribution as ae, type PollPage as af, type PreflightResult as ag, type ResilientFetchOptions as ah, type RetryPolicy as ai, type RunActionOptions as aj, type RunPollOptions as ak, type SessionContext as al, type StatusSuggestion as am, backoffMs as an, bundleDependencyFindings as ao, bundledRequireFindings as ap, checkConnector as aq, connectionSetup as ar, connectorManifest as as, createConnectorHarness as at, drainPoll as au, esbuildBundle as av, escapedMockHttp as aw, footerToolName as ax, formatFindings as ay, handlerToolName as az, type ExtensionHostMethod as b, type ConnectorDefinition as c, type Connector as d, type ExtensionDefinition as e, type ConnectorConfig as f, type ExtensionHost as g, type PollOutcome as h, type ConnectorItem as i, type PostReceiveOp as j, type ActionContext as k, type ActionDefinition as l, type ActionInputField as m, type ActionInputOption as n, type ActionInputType as o, type ActionOutputField as p, type ActivationPredicate as q, type AuthRung as r, type BrowserSignIn as s, CHECK_OWNERS as t, type CheckCode as u, type CheckOptions as v, type ConformanceRun as w, type ConnectionSetup as x, type ConnectorAuth as y, type ConnectorConfigField as z };

package/dist/{chunk-FHGC7LE7.js → chunk-ZKHXHE3O.js}

@@ -1,9 +1,134 @@
+// src/loopback.ts
+var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "[::1]"];
+function loopbackEndpoint(env, names, fail = (message) => new Error(message)) {
+  const url = env[names.urlVar]?.trim();
+  const token = env[names.tokenVar]?.trim();
+  if (!url || !token) throw fail(names.missing);
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw fail(`${names.urlVar} is ${JSON.stringify(url)}, which is not a URL`);
+  }
+  if (parsed.protocol !== "http:" || !LOOPBACK_HOSTS.includes(parsed.hostname)) {
+    throw fail(
+      `${names.urlVar} is ${JSON.stringify(url)}; ${names.served}, over http on ${LOOPBACK_HOSTS.join(", ")}`
+    );
+  }
+  return { url: url.replace(/\/$/, ""), token };
+}
+
+// src/session.ts
+var BROWSER_HOST_ENV = "VORN_BROWSER_HOST";
+var BROWSER_TOKEN_ENV = "VORN_BROWSER_TOKEN";
+var SESSION_CALL_META = "vorn/sessionCall";
+var SESSION_CALL_HEADER = "x-vorn-session-call";
+var SessionUnavailableError = class extends Error {
+  /** Asking again cannot bring the window back, so the SDK's retries let this through at once. */
+  retryable = false;
+  constructor(message) {
+    super(message);
+    this.name = "SessionUnavailableError";
+  }
+};
+var SessionRefusedError = class extends Error {
+  retryable = false;
+  constructor(message) {
+    super(message);
+    this.name = "SessionRefusedError";
+  }
+};
+var SESSION_TIMEOUT_MS = 45e3;
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function readReply(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error("The signed-in window answered with a body that is not JSON");
+  }
+  const reply2 = parsed;
+  if (!parsed || typeof parsed !== "object" || typeof reply2.status !== "number") {
+    throw new Error("The signed-in window answered without a status");
+  }
+  return reply2;
+}
+var refusal = (text) => text.trim() || void 0;
+function createSessionFetch(options = {}) {
+  const env = options.env ?? process.env;
+  const call = options.fetchImpl ?? fetch;
+  return (async (input, init) => {
+    const { url, token } = loopbackEndpoint(
+      env,
+      {
+        urlVar: BROWSER_HOST_ENV,
+        tokenVar: BROWSER_TOKEN_ENV,
+        missing: `This connector acts through a signed-in Vorn window; run it from Vorn, which sets ${BROWSER_HOST_ENV}`,
+        served: "the endpoint is served on this machine"
+      },
+      (message) => new SessionUnavailableError(message)
+    );
+    const request = new Request(input, init);
+    const body = request.body ? await request.text() : void 0;
+    const answer = await call(`${url}/fetch`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+        ...options.call && { [SESSION_CALL_HEADER]: options.call }
+      },
+      body: JSON.stringify({
+        url: request.url,
+        method: request.method,
+        headers: Object.fromEntries(request.headers),
+        ...body !== void 0 && { body }
+      }),
+      signal: AbortSignal.any([request.signal, AbortSignal.timeout(SESSION_TIMEOUT_MS)])
+    });
+    const text = await answer.text();
+    if (answer.status === 503) {
+      throw new SessionUnavailableError(
+        refusal(text) ?? "Vorn could not reach the signed-in window"
+      );
+    }
+    if (!answer.ok) {
+      throw new SessionRefusedError(
+        refusal(text) ?? `The signed-in window refused the call with HTTP ${answer.status}`
+      );
+    }
+    const reply2 = readReply(text);
+    return new Response(NULL_BODY_STATUSES.has(reply2.status) ? null : reply2.body ?? "", {
+      status: reply2.status,
+      ...reply2.headers && { headers: reply2.headers }
+    });
+  });
+}
+
+// src/origins.ts
+var ORIGIN_PATTERN = /^https:\/\/(\*\.)?[a-z0-9-]+(\.[a-z0-9-]+)+$/i;
+function withinOrigins(origins, url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:" || parsed.port !== "") return false;
+  const target = parsed.hostname.toLowerCase();
+  return origins.some((origin) => {
+    if (!ORIGIN_PATTERN.test(origin)) return false;
+    const wildcard = origin.startsWith("https://*.");
+    const host = origin.slice(wildcard ? "https://*.".length : "https://".length).toLowerCase();
+    return wildcard ? target.endsWith(`.${host}`) : target === host;
+  });
+}
+
 // src/define.ts
 var KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
 var PATH_DATA_PATTERN = /^[MmZzLlHhVvCcSsQqTtAa0-9\s,.\-+eE]+$/;
 var VIEW_BOX_PATTERN = /^-?[\d.]+\s+-?[\d.]+\s+-?[\d.]+\s+-?[\d.]+$/;
 var DEDUPE_STRATEGIES = ["timestamp", "lastItem"];
-var AUTH_RUNGS = ["none", "cli", "key", "oauth"];
+var AUTH_RUNGS = ["none", "cli", "key", "browser", "oauth"];
 var EXTENSION_PERMISSIONS = [
   "git.read",
   "terminal.read",
@@ -106,15 +231,46 @@ function assertAuth(definition) {
       }
     }
   }
-  if (auth.rung === "none") {
+  if (auth.rung === "browser") assertBrowserSignIn(id, auth.browser);
+  if (auth.rung === "none" || auth.rung === "browser") {
     const secret = (definition.config ?? []).find((field) => field.secret === true);
     if (secret) {
+      const claim = auth.rung === "none" ? "needs no sign-in" : "signs in through a Vorn window";
       throw new Error(
-        `Connector ${id} claims it needs no sign-in but declares secret field "${secret.key}"`
+        `Connector ${id} claims it ${claim} but declares secret field "${secret.key}"`
       );
     }
   }
 }
+function assertBrowserSignIn(id, browser) {
+  if (!browser) {
+    throw new Error(
+      `Connector ${id} signs in through a Vorn window but declares no browser sign-in`
+    );
+  }
+  const origins = Array.isArray(browser.origins) ? browser.origins : [];
+  const bad = origins.find((origin) => typeof origin !== "string" || !ORIGIN_PATTERN.test(origin));
+  if (origins.length === 0 || bad !== void 0) {
+    throw new Error(
+      `Connector ${id} must name its origins as https://host or https://*.host` + (bad !== void 0 ? `; ${JSON.stringify(bad)} is neither` : "")
+    );
+  }
+  const places = [
+    ["sign-in page", browser.signInUrl],
+    ["signed-in check", browser.check?.url]
+  ];
+  for (const [what, url] of places) {
+    if (typeof url !== "string" || !withinOrigins(origins, url)) {
+      throw new Error(
+        `Connector ${id} puts its ${what} ${JSON.stringify(url ?? "")} outside its origins`
+      );
+    }
+  }
+  const identity = browser.check?.identity;
+  if (!Array.isArray(identity) || identity.some((path) => typeof path !== "string" || !path.trim())) {
+    throw new Error(`Connector ${id} must name its identity fields as non-empty strings`);
+  }
+}
 function assertIdentity(kind, definition) {
   if (!KEY_PATTERN.test(definition.id ?? "")) {
     throw new Error(`${kind} id "${definition.id}" must start with a letter and be url-safe`);
@@ -909,27 +1065,13 @@ var HostReplyError = class extends Error {
   }
 };
 var HOST_TIMEOUT_MS = 15e3;
-var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "[::1]"];
 function endpoint(env) {
-  const url = env[HOST_URL_ENV]?.trim();
-  const token = env[HOST_TOKEN_ENV]?.trim();
-  if (!url || !token) {
-    throw new Error(
-      `This extension was started without a host bridge; ${HOST_URL_ENV} and ${HOST_TOKEN_ENV} are set by Vorn`
-    );
-  }
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`${HOST_URL_ENV} is ${JSON.stringify(url)}, which is not a URL`);
-  }
-  if (parsed.protocol !== "http:" || !LOOPBACK_HOSTS.includes(parsed.hostname)) {
-    throw new Error(
-      `${HOST_URL_ENV} is ${JSON.stringify(url)}; the bridge is served on this machine, over http on ${LOOPBACK_HOSTS.join(", ")}`
-    );
-  }
-  return { url: url.replace(/\/$/, ""), token };
+  return loopbackEndpoint(env, {
+    urlVar: HOST_URL_ENV,
+    tokenVar: HOST_TOKEN_ENV,
+    missing: `This extension was started without a host bridge; ${HOST_URL_ENV} and ${HOST_TOKEN_ENV} are set by Vorn`,
+    served: "the bridge is served on this machine"
+  });
 }
 function createExtensionHost(options) {
   const env = options.env ?? process.env;
@@ -1125,7 +1267,8 @@ async function pollWithDedupe(trigger, context) {
       ...state2 && { lastItemId: state2.id },
       ...context.limit !== void 0 && { limit: context.limit },
       now: context.now,
-      fetch: context.fetch
+      fetch: context.fetch,
+      ...context.session && { session: context.session }
     });
     return lastItemPoll(fetched2, state2, context, polledAt);
   }
@@ -1136,7 +1279,8 @@ async function pollWithDedupe(trigger, context) {
     ...since !== void 0 && { since },
     ...context.limit !== void 0 && { limit: context.limit },
     now: context.now,
-    fetch: context.fetch
+    fetch: context.fetch,
+    ...context.session && { session: context.session }
   });
   return timestampPoll(fetched, state, context, polledAt);
 }
@@ -1440,6 +1584,9 @@ function backoffMs(attempt, policy = {}) {
   const max = policy.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
   return Math.min(max, base * 2 ** attempt);
 }
+function isFinal(error) {
+  return error?.retryable === false;
+}
 function resilientFetch(options) {
   const attempts = Math.min(MAX_ATTEMPTS, Math.max(1, options.retry?.attempts ?? DEFAULT_ATTEMPTS));
   const sleep = options.sleep ?? wait;
@@ -1462,7 +1609,7 @@ function resilientFetch(options) {
         const delay = asked === void 0 ? backoffMs(attempt, options.retry) : Math.min(asked, ceiling);
         if (!await pause(delay)) return response;
       } catch (error) {
-        if (!options.retryable || last) throw error;
+        if (!options.retryable || last || isFinal(error)) throw error;
         if (!await pause(backoffMs(attempt, options.retry))) throw error;
       }
     }
@@ -1472,6 +1619,19 @@ function resilientFetch(options) {
 }
 
 // src/runtime.ts
+function wrap(fetchImpl, options, retryable) {
+  return resilientFetch({
+    fetchImpl,
+    retryable,
+    ...options.retry !== void 0 && { retry: options.retry },
+    ...options.sleep !== void 0 && { sleep: options.sleep }
+  });
+}
+function sessionFor(connector, options, retryable) {
+  if (connector.auth?.rung !== "browser") return void 0;
+  const fetchImpl = options.sessionFetchImpl ?? createSessionFetch(options.sessionCall ? { call: options.sessionCall } : {});
+  return { fetch: wrap(fetchImpl, options, retryable) };
+}
 var MAX_POLL_PAGES = 1e3;
 async function runPoll(connector, triggerType, options = {}) {
   const trigger = connector.triggers.find((entry) => entry.type === triggerType);
@@ -1480,6 +1640,7 @@ async function runPoll(connector, triggerType, options = {}) {
   }
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const polledAt = now();
+  const session = sessionFor(connector, options, true);
   const context = {
     config: options.config ?? {},
     ...options.since !== void 0 && { since: options.since },
@@ -1487,12 +1648,8 @@ async function runPoll(connector, triggerType, options = {}) {
     ...options.limit !== void 0 && { limit: options.limit },
     now,
     // A poll only reads, so every failure it meets is worth trying again.
-    fetch: resilientFetch({
-      fetchImpl: options.fetchImpl ?? globalThis.fetch,
-      retryable: true,
-      ...options.retry !== void 0 && { retry: options.retry },
-      ...options.sleep !== void 0 && { sleep: options.sleep }
-    })
+    fetch: wrap(options.fetchImpl ?? globalThis.fetch, options, true),
+    ...session && { session }
   };
   const outcome = typeof trigger.poll === "function" ? await trigger.poll(context) : await pollWithDedupe(trigger, context);
   if (!outcome || !Array.isArray(outcome.items)) {
@@ -1530,15 +1687,12 @@ async function runOptions(connector, name, options = {}) {
   if (!loader) {
     throw new Error(`Connector ${connector.id} serves no options set "${name}"`);
   }
+  const session = sessionFor(connector, options, true);
   const loaded = await loader({
     config: options.config ?? {},
     now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
-    fetch: resilientFetch({
-      fetchImpl: options.fetchImpl ?? globalThis.fetch,
-      retryable: true,
-      ...options.retry !== void 0 && { retry: options.retry },
-      ...options.sleep !== void 0 && { sleep: options.sleep }
-    })
+    fetch: wrap(options.fetchImpl ?? globalThis.fetch, options, true),
+    ...session && { session }
   });
   if (!Array.isArray(loaded)) {
     throw new Error(`Options set "${name}" did not return an array`);
@@ -1597,19 +1751,15 @@ async function runAction(connector, actionType, args, options = {}) {
   const config = options.config ?? {};
   const method = (action.request?.method ?? "GET").toUpperCase();
   const retryable = action.idempotent === true || action.request !== void 0 && SAFE_METHODS.has(method);
-  const fetchImpl = resilientFetch({
-    fetchImpl: options.fetchImpl ?? globalThis.fetch,
-    retryable,
-    ...options.retry !== void 0 && { retry: options.retry },
-    ...options.sleep !== void 0 && { sleep: options.sleep }
-  });
+  const fetchImpl = wrap(options.fetchImpl ?? globalThis.fetch, options, retryable);
+  const session = sessionFor(connector, options, retryable);
   if (action.request !== void 0) {
     try {
       return await executeRequest(
         action.request,
         action.postReceive,
         { args: coerced, config },
-        { fetchImpl }
+        { fetchImpl: session?.fetch ?? fetchImpl }
       );
     } catch (error) {
       throw new Error(
@@ -1624,7 +1774,8 @@ async function runAction(connector, actionType, args, options = {}) {
   const output = await action.run(coerced, {
     config,
     now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
-    fetch: fetchImpl
+    fetch: fetchImpl,
+    ...session && { session }
   });
   return output ?? {};
 }
@@ -1692,10 +1843,12 @@ async function withMockHttp(routes, body) {
   }
 }
 function createConnectorHarness(connector, harnessOptions = {}) {
+  const signedIn = harnessOptions.sessionFetchImpl ?? harnessOptions.fetchImpl;
   const defaults = (options = {}) => ({
     ...harnessOptions.config && { config: harnessOptions.config },
     ...harnessOptions.now && { now: harnessOptions.now },
     ...harnessOptions.fetchImpl && { fetchImpl: harnessOptions.fetchImpl },
+    ...signedIn && { sessionFetchImpl: signedIn },
     ...harnessOptions.sleep && { sleep: harnessOptions.sleep },
     ...options
   });
@@ -1706,6 +1859,7 @@ function createConnectorHarness(connector, harnessOptions = {}) {
       ...harnessOptions.config && { config: harnessOptions.config },
       ...harnessOptions.now && { now: harnessOptions.now },
       ...harnessOptions.fetchImpl && { fetchImpl: harnessOptions.fetchImpl },
+      ...signedIn && { sessionFetchImpl: signedIn },
       ...harnessOptions.sleep && { sleep: harnessOptions.sleep }
     }),
     manifest: () => connectorManifest(connector),
@@ -1927,7 +2081,8 @@ async function mockFindings(connector, options) {
       try {
         await runAction(connector, action.type, args, {
           config,
-          ...options.now && { now: options.now }
+          ...options.now && { now: options.now },
+          sessionFetchImpl: globalThis.fetch
         });
         return void 0;
       } catch (error) {
@@ -2116,6 +2271,9 @@ function liveRunnable(action) {
 function liveExamines(connector) {
   return connector.preflight !== void 0 || connector.actions.some(liveRunnable);
 }
+function needsWindow(error) {
+  return error instanceof SessionUnavailableError || error instanceof Error && error.cause instanceof SessionUnavailableError;
+}
 async function liveFindings(connector, options) {
   if (!options.live) return [];
   const found = [];
@@ -2146,6 +2304,7 @@ async function liveFindings(connector, options) {
         ...options.now && { now: options.now }
       });
     } catch (error) {
+      if (needsWindow(error)) continue;
       const reason = error instanceof Error ? error.message : String(error);
       found.push(
         finding2(
@@ -3028,6 +3187,10 @@ function scaffoldFiles(options) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+function sessionCallOf(extra) {
+  const key = extra._meta?.[SESSION_CALL_META];
+  return typeof key === "string" ? { sessionCall: key } : {};
+}
 function json(value) {
   return {
     // Vorn reads `structuredContent` to build step output and to find the
@@ -3129,12 +3292,13 @@ function createConnectorServer(connector, options = {}) {
           options: z.array(z.looseObject({ value: z.string(), label: z.string().optional() })).describe("The choices, each a value to send and words to show")
         })
       },
-      async (args) => {
+      async (args, extra) => {
         try {
           return json({
             options: await runOptions(connector, args.name, {
               config: config(),
-              ...options.now && { now: options.now }
+              ...options.now && { now: options.now },
+              ...sessionCallOf(extra)
             })
           });
         } catch (error) {
@@ -3159,7 +3323,7 @@ function createConnectorServer(connector, options = {}) {
           hasMore: z.boolean().describe("Whether another page is immediately available")
         })
       },
-      async (args) => {
+      async (args, extra) => {
         try {
           const limit = args.limit === void 0 ? void 0 : Number(args.limit);
           if (limit !== void 0 && !Number.isFinite(limit)) {
@@ -3171,7 +3335,8 @@ function createConnectorServer(connector, options = {}) {
               ...args.since !== void 0 && { since: args.since },
               ...args.cursor !== void 0 && { cursor: args.cursor },
               ...limit !== void 0 && { limit },
-              ...options.now && { now: options.now }
+              ...options.now && { now: options.now },
+              ...sessionCallOf(extra)
             })
           );
         } catch (error) {
@@ -3253,12 +3418,13 @@ function createConnectorServer(connector, options = {}) {
         inputSchema: inputShape(action.inputs ?? []),
         outputSchema: outputSchema(action.outputs ?? [])
       },
-      async (args) => {
+      async (args, extra) => {
         try {
           return json(
             await runAction(connector, action.type, args, {
               config: config(),
-              ...options.now && { now: options.now }
+              ...options.now && { now: options.now },
+              ...sessionCallOf(extra)
             })
           );
         } catch (error) {
@@ -3275,6 +3441,15 @@ async function serveConnector(connector, options = {}) {
 }
 
 export {
+  BROWSER_HOST_ENV,
+  BROWSER_TOKEN_ENV,
+  SESSION_CALL_META,
+  SESSION_CALL_HEADER,
+  SessionUnavailableError,
+  SessionRefusedError,
+  createSessionFetch,
+  ORIGIN_PATTERN,
+  withinOrigins,
   EXTENSION_PERMISSIONS,
   HOST_PERMISSIONS,
   envNameFor,

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { B as BundleRequest, a as BundleOutput, C as CheckFinding } from './check-Cv6UNBA4.js';
+import { B as BundleRequest, a as BundleOutput, C as CheckFinding } from './check-62s2GvcO.js';
 
 interface CliDeps {
     load(modulePath: string): Promise<unknown>;

package/dist/cli.js

@@ -10,7 +10,7 @@ import {
   runPoll,
   scaffoldFiles,
   serveConnector
-} from "./chunk-FHGC7LE7.js";
+} from "./chunk-ZKHXHE3O.js";
 
 // src/cli.ts
 import { fileURLToPath, pathToFileURL } from "url";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { E as ExtensionPermission, b as ExtensionHostMethod, c as ConnectorDefinition, d as Connector, e as ExtensionDefinition, f as ConnectorConfig, g as ExtensionHost, T as TriggerDefinition, P as PollContext, h as PollOutcome, i as ConnectorItem, N as NormalizedItem, j as PostReceiveOp, A as ActionRequest, B as BundleRequest, a as BundleOutput, C as CheckFinding } from './check-Cv6UNBA4.js';
-export { k as ActionContext, l as ActionDefinition, m as ActionInputField, n as ActionInputOption, o as ActionInputType, p as ActionOutputField, q as ActivationPredicate, r as AuthRung, s as CHECK_OWNERS, t as CheckCode, u as CheckOptions, v as ConformanceRun, w as ConnectionSetup, x as ConnectorAuth, y as ConnectorConfigField, z as ConnectorHarness, D as ConnectorIcon, F as ConnectorKind, G as ConnectorManifest, H as ConnectorVerification, I as DedupeStrategy, J as DefaultWorkflow, K as ExtensionAgent, L as ExtensionContext, M as ExtensionContributions, O as ExtensionPlatform, Q as ExtensionUsage, R as ExtensionUsageWindow, S as FetchContext, U as FooterContribution, V as FooterItem, W as HarnessOptions, X as LinkContext, Y as LinkHandled, Z as LinkHandlerContribution, _ as MANIFEST_TOOL, $ as MAX_PACK_BYTES, a0 as MAX_POLL_PAGES, a1 as ManifestContributions, a2 as MockCall, a3 as MockHostAnswers, a4 as MockHostRun, a5 as MockRoute, a6 as MockRouteMissError, a7 as MockRun, a8 as OPTIONS_TOOL, a9 as OptionsContext, aa as OptionsLoader, ab as PREFLIGHT_TOOL, ac as PaginationStrategy, ad as PaneContribution, ae as PollPage, af as PreflightResult, ag as ResilientFetchOptions, ah as RetryPolicy, ai as RunActionOptions, aj as RunPollOptions, ak as StatusSuggestion, al as backoffMs, am as bundleDependencyFindings, an as bundledRequireFindings, ao as checkConnector, ap as connectionSetup, aq as connectorManifest, ar as createConnectorHarness, as as drainPoll, at as esbuildBundle, au as escapedMockHttp, av as footerToolName, aw as formatFindings, ax as handlerToolName, ay as lifecycleScriptFindings, az as mockExtensionHost, aA as pollToolName, aB as readNearestPackageJson, aC as resilientFetch, aD as retryAfterMs, aE as runAction, aF as runConformance, aG as runOptions, aH as runPoll, aI as withMockHttp } from './check-Cv6UNBA4.js';
+import { E as ExtensionPermission, b as ExtensionHostMethod, c as ConnectorDefinition, d as Connector, e as ExtensionDefinition, f as ConnectorConfig, g as ExtensionHost, T as TriggerDefinition, P as PollContext, h as PollOutcome, i as ConnectorItem, N as NormalizedItem, j as PostReceiveOp, A as ActionRequest, B as BundleRequest, a as BundleOutput, C as CheckFinding } from './check-62s2GvcO.js';
+export { k as ActionContext, l as ActionDefinition, m as ActionInputField, n as ActionInputOption, o as ActionInputType, p as ActionOutputField, q as ActivationPredicate, r as AuthRung, s as BrowserSignIn, t as CHECK_OWNERS, u as CheckCode, v as CheckOptions, w as ConformanceRun, x as ConnectionSetup, y as ConnectorAuth, z as ConnectorConfigField, D as ConnectorHarness, F as ConnectorIcon, G as ConnectorKind, H as ConnectorManifest, I as ConnectorVerification, J as DedupeStrategy, K as DefaultWorkflow, L as ExtensionAgent, M as ExtensionContext, O as ExtensionContributions, Q as ExtensionPlatform, R as ExtensionUsage, S as ExtensionUsageWindow, U as FetchContext, V as FooterContribution, W as FooterItem, X as HarnessOptions, Y as LinkContext, Z as LinkHandled, _ as LinkHandlerContribution, $ as MANIFEST_TOOL, a0 as MAX_PACK_BYTES, a1 as MAX_POLL_PAGES, a2 as ManifestContributions, a3 as MockCall, a4 as MockHostAnswers, a5 as MockHostRun, a6 as MockRoute, a7 as MockRouteMissError, a8 as MockRun, a9 as OPTIONS_TOOL, aa as OptionsContext, ab as OptionsLoader, ac as PREFLIGHT_TOOL, ad as PaginationStrategy, ae as PaneContribution, af as PollPage, ag as PreflightResult, ah as ResilientFetchOptions, ai as RetryPolicy, aj as RunActionOptions, ak as RunPollOptions, al as SessionContext, am as StatusSuggestion, an as backoffMs, ao as bundleDependencyFindings, ap as bundledRequireFindings, aq as checkConnector, ar as connectionSetup, as as connectorManifest, at as createConnectorHarness, au as drainPoll, av as esbuildBundle, aw as escapedMockHttp, ax as footerToolName, ay as formatFindings, az as handlerToolName, aA as lifecycleScriptFindings, aB as mockExtensionHost, aC as pollToolName, aD as readNearestPackageJson, aE as resilientFetch, aF as retryAfterMs, aG as runAction, aH as runConformance, aI as runOptions, aJ as runPoll, aK as withMockHttp } from './check-62s2GvcO.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 
 /** Everything an extension may ask the host for; anything else is not grantable. */
@@ -59,6 +59,38 @@ interface HostBridgeOptions {
 /** The host as an extension process reaches it, over the bridge Vorn served it. */
 declare function createExtensionHost(options: HostBridgeOptions): ExtensionHost;
 
+/** Where Vorn serves a browser-sign-in connector the window it signed in through. */
+declare const BROWSER_HOST_ENV = "VORN_BROWSER_HOST";
+declare const BROWSER_TOKEN_ENV = "VORN_BROWSER_TOKEN";
+/** The tool call a window request belongs to, so Vorn can tell a step's own requests from another's. */
+declare const SESSION_CALL_META = "vorn/sessionCall";
+declare const SESSION_CALL_HEADER = "x-vorn-session-call";
+/** The signed-in window could not make the call: Vorn is closed, too old, or not the caller. */
+declare class SessionUnavailableError extends Error {
+    /** Asking again cannot bring the window back, so the SDK's retries let this through at once. */
+    readonly retryable = false;
+    constructor(message: string);
+}
+/** Vorn refused the call itself, for instance because it is off the connector's origins. */
+declare class SessionRefusedError extends Error {
+    readonly retryable = false;
+    constructor(message: string);
+}
+interface SessionFetchOptions {
+    env?: NodeJS.ProcessEnv;
+    /** Replaced in tests so nothing opens a socket. */
+    fetchImpl?: typeof fetch;
+    /** The key of the tool call these requests belong to, from its MCP metadata. */
+    call?: string;
+}
+/** A fetch whose requests run inside the connection's signed-in Vorn window, so no cookie reaches this process. */
+declare function createSessionFetch(options?: SessionFetchOptions): typeof fetch;
+
+/** An origin a connector may act on: `https://host`, or `https://*.host` for every subdomain. */
+declare const ORIGIN_PATTERN: RegExp;
+/** Whether `url` is on one of the declared origins. */
+declare function withinOrigins(origins: readonly string[], url: string): boolean;
+
 /**
  * Run a declarative trigger: call the author's `fetch`, then apply the chosen
  * dedupe strategy.
@@ -223,4 +255,4 @@ declare function titleCase(id: string): string;
 /** Every file a new connector or extension starts with, ready to build, check and pack. */
 declare function scaffoldFiles(options: ScaffoldOptions): ScaffoldFile[];
 
-export { ActionRequest, BundleOutput, BundleRequest, CheckFinding, Connector, ConnectorConfig, ConnectorDefinition, ConnectorItem, type ConnectorServerOptions, EXTENSION_PERMISSIONS, ExtensionDefinition, ExtensionHost, ExtensionHostMethod, ExtensionPermission, HOST_PERMISSIONS, HOST_TOKEN_ENV, HOST_URL_ENV, type HostBridgeOptions, MAX_REQUEST_PAGES, NormalizedItem, type PackOptions, type PackResult, PermissionDeniedError, PollContext, PollOutcome, PostReceiveOp, type RequestScope, type ResolvedRequest, type ScaffoldFile, type ScaffoldOptions, type Substitution, TriggerDefinition, applyPostReceive, asOutput, createConnectorServer, createExtensionHost, defineConnector, defineExtension, envNameFor, executeRequest, nextLink, normalizeItem, normalizeItems, packConnector, packFileName, pollWithDedupe, resolveConfig, resolveRequest, resolveTemplates, scaffoldFiles, serveConnector, titleCase, valueAt };
+export { ActionRequest, BROWSER_HOST_ENV, BROWSER_TOKEN_ENV, BundleOutput, BundleRequest, CheckFinding, Connector, ConnectorConfig, ConnectorDefinition, ConnectorItem, type ConnectorServerOptions, EXTENSION_PERMISSIONS, ExtensionDefinition, ExtensionHost, ExtensionHostMethod, ExtensionPermission, HOST_PERMISSIONS, HOST_TOKEN_ENV, HOST_URL_ENV, type HostBridgeOptions, MAX_REQUEST_PAGES, NormalizedItem, ORIGIN_PATTERN, type PackOptions, type PackResult, PermissionDeniedError, PollContext, PollOutcome, PostReceiveOp, type RequestScope, type ResolvedRequest, SESSION_CALL_HEADER, SESSION_CALL_META, type ScaffoldFile, type ScaffoldOptions, type SessionFetchOptions, SessionRefusedError, SessionUnavailableError, type Substitution, TriggerDefinition, applyPostReceive, asOutput, createConnectorServer, createExtensionHost, createSessionFetch, defineConnector, defineExtension, envNameFor, executeRequest, nextLink, normalizeItem, normalizeItems, packConnector, packFileName, pollWithDedupe, resolveConfig, resolveRequest, resolveTemplates, scaffoldFiles, serveConnector, titleCase, valueAt, withinOrigins };

package/dist/index.js

@@ -1,4 +1,6 @@
 import {
+  BROWSER_HOST_ENV,
+  BROWSER_TOKEN_ENV,
   CHECK_OWNERS,
   EXTENSION_PERMISSIONS,
   HOST_PERMISSIONS,
@@ -10,8 +12,13 @@ import {
   MAX_REQUEST_PAGES,
   MockRouteMissError,
   OPTIONS_TOOL,
+  ORIGIN_PATTERN,
   PREFLIGHT_TOOL,
   PermissionDeniedError,
+  SESSION_CALL_HEADER,
+  SESSION_CALL_META,
+  SessionRefusedError,
+  SessionUnavailableError,
   applyPostReceive,
   asOutput,
   backoffMs,
@@ -23,6 +30,7 @@ import {
   createConnectorHarness,
   createConnectorServer,
   createExtensionHost,
+  createSessionFetch,
   defineConnector,
   defineExtension,
   drainPoll,
@@ -56,9 +64,12 @@ import {
   serveConnector,
   titleCase,
   valueAt,
-  withMockHttp
-} from "./chunk-FHGC7LE7.js";
+  withMockHttp,
+  withinOrigins
+} from "./chunk-ZKHXHE3O.js";
 export {
+  BROWSER_HOST_ENV,
+  BROWSER_TOKEN_ENV,
   CHECK_OWNERS,
   EXTENSION_PERMISSIONS,
   HOST_PERMISSIONS,
@@ -70,8 +81,13 @@ export {
   MAX_REQUEST_PAGES,
   MockRouteMissError,
   OPTIONS_TOOL,
+  ORIGIN_PATTERN,
   PREFLIGHT_TOOL,
   PermissionDeniedError,
+  SESSION_CALL_HEADER,
+  SESSION_CALL_META,
+  SessionRefusedError,
+  SessionUnavailableError,
   applyPostReceive,
   asOutput,
   backoffMs,
@@ -83,6 +99,7 @@ export {
   createConnectorHarness,
   createConnectorServer,
   createExtensionHost,
+  createSessionFetch,
   defineConnector,
   defineExtension,
   drainPoll,
@@ -116,5 +133,6 @@ export {
   serveConnector,
   titleCase,
   valueAt,
-  withMockHttp
+  withMockHttp,
+  withinOrigins
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vornrun/connector-sdk",
-  "version": "0.7.0-beta.17",
+  "version": "0.7.0-beta.19",
   "description": "Build and share Vorn pull connectors as ordinary npm packages",
   "type": "module",
   "license": "MIT",