@vornrun/connector-sdk 0.7.0-beta.7 → 0.7.0

package/dist/index.d.ts

@@ -1,272 +1,11 @@
+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';
 
-/**
- * Author-facing types for Vorn connectors.
- *
- * A connector written with this SDK runs as an ordinary MCP stdio server, so
- * it is shared as a normal npm package and installed by pointing a Vorn
- * connection at `npx -y <package>`. Nothing about the host app has to change
- * to accept a new connector.
- */
-/** A raw item as the author's code returns it. Only id and title are required. */
-interface ConnectorItem {
-    /** Stable upstream identity. Vorn dedupes on this, so it must not change. */
-    externalId: string | number;
-    title: string;
-    url?: string;
-    description?: string;
-    /** Raw upstream status (`open`, `Active`, `In Progress`, …). */
-    status?: string;
-    labels?: string[];
-    assignee?: string;
-    /**
-     * When the item last changed. Vorn advances its poll cursor from this field,
-     * so it must be monotonic per item and comparable as an ISO 8601 string.
-     * Defaults to poll time when omitted.
-     */
-    updatedAt?: string | Date;
-    /** Extra fields to expose to workflow templates as `{{trigger.item.<key>}}`. */
-    data?: Record<string, unknown>;
-}
-/** A connector item after normalization. This is the exact JSON Vorn sees. */
-interface NormalizedItem extends Record<string, unknown> {
-    externalId: string;
-    title: string;
-    url: string;
-    description: string;
-    status: string;
-    labels: string[];
-    updatedAt: string;
-    assignee?: string;
-}
-/** Declares a value the connector needs at runtime, read from the environment. */
-interface ConnectorConfigField {
-    key: string;
-    label: string;
-    /** Environment variable the value is read from. Defaults to CONSTANT_CASE(key). */
-    env?: string;
-    required?: boolean;
-    /** Secrets are stored encrypted by Vorn and never printed by the CLI. */
-    secret?: boolean;
-    description?: string;
-    default?: string;
-}
-type ConnectorConfig = Record<string, string | undefined>;
-interface PollContext {
-    config: ConnectorConfig;
-    /**
-     * Lower bound the host asked for, when it was able to supply one. Treat it
-     * as a hint: returning older items is safe because Vorn dedupes, but
-     * returning fewer than everything after `since` loses events.
-     */
-    since?: string;
-    /** Opaque cursor previously returned by this trigger, when supplied. */
-    cursor?: string;
-    /** Upper bound on items to return in one page. */
-    limit?: number;
-    /** Injectable clock so tests are deterministic. */
-    now(): string;
-}
-interface PollOutcome {
-    items: ConnectorItem[];
-    nextCursor?: string;
-    hasMore?: boolean;
-}
-/**
- * How the SDK decides which fetched items are new.
- *
- * - `timestamp` — for sources that expose a reliable "last changed" field and
- *   can filter on it. Handles the boundary case where several items share the
- *   newest timestamp, which is the classic source of both duplicates and
- *   silently dropped items.
- * - `lastItem` — for feeds that return newest-first with no dependable
- *   timestamp. The cursor is the newest id already delivered.
- */
-type DedupeStrategy = 'timestamp' | 'lastItem';
-/**
- * What a declarative trigger's `fetch` receives. Deliberately smaller than
- * {@link PollContext}: cursor encoding, ordering, windowing and de-duplication
- * are the SDK's job, so the author only has to answer "what is there now?".
- */
-interface FetchContext {
-    config: ConnectorConfig;
-    /**
-     * With `dedupe: 'timestamp'`, everything changed at or after this instant is
-     * worth returning. Absent on the very first poll. Returning a little too
-     * much is safe — the SDK drops what was already delivered.
-     */
-    since?: string;
-    /**
-     * With `dedupe: 'lastItem'`, the newest id already delivered. Absent on the
-     * very first poll. Return the feed newest-first and the SDK will stop there.
-     */
-    lastItemId?: string;
-    /** Upper bound on items worth returning in one call. */
-    limit?: number;
-    /** Injectable clock so tests are deterministic. */
-    now(): string;
-}
-/**
- * What an upstream state should become when an item is imported as a task.
- *
- * A suggestion, not a rule: it seeds the connection form, and the person
- * setting it up can change it. Without any, everything a connector imports
- * lands as `todo` regardless of whether it was closed a year ago.
- */
-interface StatusSuggestion {
-    /** The value the connector reports in `ConnectorItem.status`. */
-    upstream: string;
-    suggestedLocal: 'todo' | 'in_progress' | 'in_review' | 'done' | 'cancelled';
-}
-/**
- * The workflow to create when a connection is made.
- *
- * A connector that fires on a schedule is useless until something polls it, and
- * expecting every person to build that workflow by hand is how a connection
- * ends up configured and silent. Seeded workflows are ordinary, visible and
- * editable — the schedule is a starting point, not a fixed rule.
- */
-interface DefaultWorkflow {
-    name: string;
-    defaultCronFromMinutes: number;
-}
-interface TriggerBase {
-    /** Event key, e.g. `workItemCreated`. Becomes the `poll_<type>` MCP tool. */
-    type: string;
-    label: string;
-    description?: string;
-    /** Seeds the connection's status mapping; the person setting it up owns it. */
-    statusMapping?: StatusSuggestion[];
-    /** Seeds a polling workflow when a connection is created. */
-    defaultWorkflow?: DefaultWorkflow;
-    /**
-     * Representative items. `vorn-connector check` replays these through the
-     * real dedupe pipeline, so a connector can be verified before anyone has
-     * credentials for it.
-     */
-    sample?: ConnectorItem[];
-}
-/**
- * A trigger is either declarative or hand-written, never both — expressed as a
- * union so the invalid combinations are a type error at authoring time rather
- * than a throw when the connector is first loaded.
- */
-type TriggerDefinition = TriggerBase & ({
-    /**
-     * Declarative polling: return what the source has and let the SDK
-     * handle cursors and de-duplication.
-     */
-    dedupe: DedupeStrategy;
-    fetch(context: FetchContext): Promise<ConnectorItem[]> | ConnectorItem[];
-    poll?: never;
-} | {
-    /**
-     * Full control over cursors and paging. Use only when the source's
-     * paging cannot be expressed as "give me everything since X".
-     */
-    poll(context: PollContext): Promise<PollOutcome> | PollOutcome;
-    dedupe?: never;
-    fetch?: never;
-});
-interface ActionInputField {
-    key: string;
-    label: string;
-    type?: 'string' | 'number' | 'boolean';
-    required?: boolean;
-    description?: string;
-}
-/**
- * A field the action is known to return. Declaring these is optional — extra
- * keys always pass through — but declared fields show up in Vorn's variable
- * autocomplete as `{{steps.<action>.<key>}}`.
- */
-interface ActionOutputField {
-    key: string;
-    type?: 'string' | 'number' | 'boolean';
-    description?: string;
-}
-interface ActionContext {
-    config: ConnectorConfig;
-    now(): string;
-}
-interface ActionDefinition {
-    /** Action key, e.g. `closeWorkItem`. Becomes an MCP tool of the same name. */
-    type: string;
-    label: string;
-    description?: string;
-    /**
-     * Whether repeating the call with the same arguments is safe. Surfaced in
-     * the MCP tool description, because an agent retrying a failed step has no
-     * other way to know whether it is about to create a second issue.
-     */
-    idempotent?: boolean;
-    inputs?: ActionInputField[];
-    outputs?: ActionOutputField[];
-    run(args: Record<string, unknown>, context: ActionContext): Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
-}
-/**
- * A connector's own glyph, so an installed connector is recognizable in a list
- * rather than sharing one generic icon with every other one.
- *
- * Path data only — deliberately not markup. Vorn draws these itself as
- * `<path d="...">` inside an `<svg>` it owns, so a connector cannot inject
- * elements, scripts or external references into the app rendering it.
- */
-interface ConnectorIcon {
-    /** Defaults to `0 0 24 24`. */
-    viewBox?: string;
-    /** SVG path `d` data, drawn with `fill="currentColor"` so it inherits color. */
-    paths: string[];
-}
-/**
- * What a connector reports about its own readiness.
- *
- * `message` is shown to the user verbatim, so it should say what to do rather
- * than what went wrong — "run `gh auth login`" beats "not authenticated".
- */
-interface PreflightResult {
-    ok: boolean;
-    message?: string;
-}
-interface ConnectorDefinition {
-    /** Stable connector id, e.g. `azure-devops`. */
-    id: string;
-    name: string;
-    version?: string;
-    description?: string;
-    icon?: ConnectorIcon;
-    config?: ConnectorConfigField[];
-    triggers?: TriggerDefinition[];
-    actions?: ActionDefinition[];
-    /**
-     * Whether this connector could work right now, asked before anyone waits on
-     * a poll.
-     *
-     * A connector whose credentials come from config fields does not need this:
-     * a missing field is already a visible, nameable error. One that borrows an
-     * external tool's login — `gh auth login`, `az login` — has no field to be
-     * missing, so without this the first sign that the tool is absent or signed
-     * out is a poll failing some minutes after the connection was saved.
-     *
-     * Answer `ok: false` with a message saying what to do about it. Throwing is
-     * equivalent — the server catches it and reports the same shape with the
-     * error's message — so there is one result for a caller to read and no
-     * behaviour riding on which you choose. Prefer returning when the state is
-     * one you recognise, because then you get to write the sentence.
-     *
-     * Absent means there is nothing to check, which is not the same answer as a
-     * check that passed.
-     */
-    preflight?(): Promise<PreflightResult> | PreflightResult;
-}
-/** A validated definition. Every accessor below is guaranteed non-null. */
-interface Connector extends ConnectorDefinition {
-    readonly version: string;
-    readonly config: ConnectorConfigField[];
-    readonly triggers: TriggerDefinition[];
-    readonly actions: ActionDefinition[];
-}
-
+/** Everything an extension may ask the host for; anything else is not grantable. */
+declare const EXTENSION_PERMISSIONS: ExtensionPermission[];
+/** What each host method costs, read by the bridge that grants it and the check that gates it. */
+declare const HOST_PERMISSIONS: Record<ExtensionHostMethod, ExtensionPermission>;
 /** Environment variable a config field reads from, e.g. `apiToken` → `API_TOKEN`. */
 declare function envNameFor(key: string, explicit?: string): string;
 /**
@@ -277,6 +16,15 @@ declare function envNameFor(key: string, explicit?: string): string;
  * MCP tool once the connector is already installed in someone's app.
  */
 declare function defineConnector(definition: ConnectorDefinition): Connector;
+/**
+ * Validate an extension and fill in its defaults.
+ *
+ * An extension is a pack like a connector, so it goes through the same
+ * manifest, pack, check and catalog; what differs is that it contributes to a
+ * session card rather than polling a service. Failing here — at import time —
+ * keeps a mistyped permission or an unreachable page from reaching a card.
+ */
+declare function defineExtension(definition: ExtensionDefinition): Connector;
 /**
  * Read the connector's declared config out of the environment. Vorn supplies
  * these through the connection's `env` / `secretEnv` maps, so a missing
@@ -285,35 +33,63 @@ declare function defineConnector(definition: ConnectorDefinition): Connector;
  */
 declare function resolveConfig(connector: Connector, env?: NodeJS.ProcessEnv): ConnectorConfig;
 
-interface CheckFinding {
-    /** `error` means the connector will misbehave in Vorn; `warn` is advisory. */
-    level: 'error' | 'warn';
-    code: string;
-    /** Which part of the connector the finding is about. */
-    target: string;
-    message: string;
-}
-interface CheckOptions {
-    /**
-     * Poll every trigger against the real source. Off by default, so a check
-     * runs on declared `sample` items and the definition alone.
-     */
-    live?: boolean;
-    /** Credentials, required by `live`. */
-    config?: ConnectorConfig;
-    now?: () => string;
-}
 /**
- * Check a connector against the contract Vorn relies on.
+ * How an extension asks the host for what it was granted.
  *
- * The point is a feedback loop: a connector — hand-written or generated — can
- * be verified before it is ever installed, catching the failures that are
- * otherwise invisible until duplicate tasks show up in someone's inbox days
- * later.
+ * The extension runs as its own process, so the bridge is an HTTP endpoint the
+ * host serves and names in the environment, with a token that says which
+ * extension is calling. The host grants exactly the permissions the manifest
+ * declared, which is why a call outside them comes back refused rather than
+ * empty — the same answer the check's stub gives, so an extension meets the
+ * rule once rather than twice.
  */
-declare function checkConnector(connector: Connector, options?: CheckOptions): Promise<CheckFinding[]>;
-/** Render findings for a terminal. Returns an empty string when all clear. */
-declare function formatFindings(findings: CheckFinding[]): string;
+/** Where the host answers, and the token that says who is asking. */
+declare const HOST_URL_ENV = "VORN_EXTENSION_HOST";
+declare const HOST_TOKEN_ENV = "VORN_EXTENSION_TOKEN";
+/** The host refused a call the extension's manifest never asked for. */
+declare class PermissionDeniedError extends Error {
+    constructor(method: string, detail: string);
+}
+interface HostBridgeOptions {
+    sessionId: string;
+    env?: NodeJS.ProcessEnv;
+    /** Replaced in tests so nothing opens a socket. */
+    fetchImpl?: typeof fetch;
+}
+/** 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
@@ -341,119 +117,99 @@ declare function normalizeItem(item: ConnectorItem, polledAt: string): Normalize
  */
 declare function normalizeItems(items: ConnectorItem[], polledAt: string): NormalizedItem[];
 
-interface PollPage {
-    items: NormalizedItem[];
-    nextCursor?: string;
-    hasMore: boolean;
-}
-interface RunPollOptions {
-    config?: ConnectorConfig;
-    since?: string;
-    cursor?: string;
-    limit?: number;
-    now?: () => string;
+/** The value at a dotted path, or undefined if any step is missing. */
+declare function valueAt(value: unknown, path: string): unknown;
+/** Run a response through the declared ops, left to right. */
+declare function applyPostReceive(value: unknown, ops: PostReceiveOp[] | undefined): unknown;
+
+interface RequestScope {
+    args: Record<string, unknown>;
+    config: ConnectorConfig;
 }
-/** Longest chain of pages `drainPoll` will follow before calling it a bug. */
-declare const MAX_POLL_PAGES = 1000;
 /**
- * Run one poll page and normalize it. Shared by the MCP server, the CLI and
- * the test harness so all three observe exactly what Vorn will observe.
+ * How a substituted value is written into its surroundings.
+ *
+ * A value's meaning depends on where it lands: a path segment has to be
+ * escaped, a header has characters it may not contain at all. Passing that
+ * decision in means the substitution is made safe once, here, instead of by
+ * every author who interpolates an argument.
  */
-declare function runPoll(connector: Connector, triggerType: string, options?: RunPollOptions): Promise<PollPage>;
+type Substitution = (value: string, source: 'args' | 'config') => string;
 /**
- * Follow `hasMore` to the end of a trigger's backlog. Mirrors how Vorn drains
- * a connector, including its refusal to follow a cursor that does not move —
- * so an author sees the infinite loop in a unit test instead of in the app.
+ * Resolve `{{args.x}}` and `{{config.y}}` inside a value.
+ *
+ * A whole-string placeholder keeps the referenced value's own type, so a body
+ * can carry a number or an object; a placeholder among other text is rendered
+ * into the string. An unset reference resolves to `undefined` on its own and to
+ * the empty string when it is part of a larger one, which is what lets an
+ * optional argument simply not appear.
+ *
+ * With a `substitute`, every resolved value passes through it — including a
+ * whole-string one, which then arrives as text rather than keeping its type,
+ * because a place that needs escaping is a place that holds a string.
  */
-declare function drainPoll(connector: Connector, triggerType: string, options?: RunPollOptions): Promise<NormalizedItem[]>;
-interface RunActionOptions {
-    config?: ConnectorConfig;
-    now?: () => string;
+declare function resolveTemplates(value: unknown, scope: RequestScope, substitute?: Substitution): unknown;
+interface ResolvedRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
 }
-/**
- * Run an action with its declared inputs validated and coerced. Vorn renders
- * every action argument as a template string, so numbers and booleans arrive
- * as text and have to be converted back here.
- */
-declare function runAction(connector: Connector, actionType: string, args: Record<string, unknown>, options?: RunActionOptions): Promise<Record<string, unknown>>;
-
-/** MCP tool name a trigger is served under. */
-declare function pollToolName(triggerType: string): string;
-/** Tool that reports the connector's manifest and setup hints. */
-declare const MANIFEST_TOOL = "vorn_connector_manifest";
-/**
- * Tool that reports whether the connector can run right now. Present only when
- * the connector declares a `preflight`, so its absence means "nothing to
- * check" rather than "check passed".
- */
-declare const PREFLIGHT_TOOL = "vorn_connector_preflight";
-interface ConnectionSetup {
-    connectorId: string;
-    triggerType: string;
-    /** Values to paste into Vorn's MCP connection form. */
-    filters: {
-        pollTool: string;
-        itemsPath: 'items';
-        idField: 'externalId';
-        timestampField: 'updatedAt';
-        titleField: 'title';
-        urlField: 'url';
-        cursorArg: 'cursor';
-        cursorPath: 'nextCursor';
-    };
-    /** Environment variable names the connector reads. */
-    env: Array<{
-        name: string;
-        required: boolean;
-        secret: boolean;
-        description?: string;
-    }>;
+/** Build the exact call a declared request makes, with its templates resolved. */
+declare function resolveRequest(request: ActionRequest, scope: RequestScope): ResolvedRequest;
+interface SendOptions {
+    fetchImpl: typeof fetch;
 }
 /**
- * Describe how to wire one trigger into a Vorn MCP connection.
+ * The action's result, as Vorn stores it.
  *
- * Every SDK connector normalizes to the same field names, so this mapping is
- * fixed; it is generated rather than documented so a rename in the SDK cannot
- * drift away from the setup instructions users copy. `cursorArg` hands the
- * connector back its own cursor each poll, which is what lets its dedupe
- * strategy — rather than Vorn's timestamp comparison — decide what is new.
+ * A step's output is a record, so a response that is a list becomes `items` —
+ * the name the rest of this SDK already uses for one — and any other bare
+ * value becomes `result`.
  */
-declare function connectionSetup(connector: Connector, triggerType: string): ConnectionSetup;
-interface ConnectorManifest {
-    id: string;
-    name: string;
-    version: string;
-    description?: string;
-    icon?: ConnectorIcon;
-    triggers: Array<{
-        type: string;
-        label: string;
-        description?: string;
-        /** Seeds a connection's status mapping; absent when the connector was silent. */
-        statusMapping?: StatusSuggestion[];
-        /** Seeds the polling workflow created with the connection. */
-        defaultWorkflow?: DefaultWorkflow;
-        setup: ConnectionSetup;
-    }>;
-    actions: Array<{
-        type: string;
-        label: string;
-        description?: string;
-        inputs: Array<{
-            key: string;
-            label: string;
-            type: string;
-            required: boolean;
-        }>;
-    }>;
+declare function asOutput(value: unknown): Record<string, unknown>;
+/** Longest chain of pages a declared request will follow before calling it a bug. */
+declare const MAX_REQUEST_PAGES = 100;
+/** The URL of the next page, as a paged HTTP API states it in its `Link` header. */
+declare function nextLink(header: string | null): string | undefined;
+/** Run a declared request end to end: resolve, send, follow its pages, reshape. */
+declare function executeRequest(request: ActionRequest, postReceive: PostReceiveOp[] | undefined, scope: RequestScope, options: SendOptions): Promise<Record<string, unknown>>;
+
+interface PackOptions {
+    /** Module specifier the connector was loaded from, bundled as the pack entry. */
+    entry: string;
+    /** Directory the `.vorn.tgz` is written to; defaults to the working directory. */
+    outDir?: string;
+    /** Directory module specifiers resolve from; defaults to the working directory. */
+    resolveDir?: string;
+    /** SDK specifier the generated stdio entry imports; overridden in tests. */
+    sdkModule?: string;
+    /** Size ceiling for the written archive; defaults to `MAX_PACK_BYTES`. */
+    maxBytes?: number;
+    /** Size ceiling for what the archive unpacks to; defaults to `MAX_UNPACKED_BYTES`. */
+    maxUnpackedBytes?: number;
+    /** Replaced in tests so packing does not shell out to a bundler. */
+    bundle?(request: BundleRequest): Promise<BundleOutput>;
+    /** Replaced in tests whose subject is the archive rather than the launch; defaults to starting it for real. */
+    launch?(dir: string): Promise<CheckFinding[]>;
+}
+interface PackResult {
+    findings: CheckFinding[];
+    /** Absolute path of the written pack; absent when a gate failed. */
+    file?: string;
+    bytes?: number;
 }
-/** Full machine-readable description of a connector, served over MCP and printed by the CLI. */
-declare function connectorManifest(connector: Connector): ConnectorManifest;
+/** File name Vorn recognizes as a connector pack. */
+declare function packFileName(connector: Connector): string;
+/** The entry is generated, not the author's bin, so every pack launches alike. */
+declare function packConnector(connector: Connector, options: PackOptions): Promise<PackResult>;
 
 interface ConnectorServerOptions {
     /** Resolved connector configuration. Defaults to reading `process.env`. */
     config?: ConnectorConfig;
     now?: () => string;
+    /** The host an extension's contributions talk to; defaults to the bridge Vorn served. */
+    host?(sessionId: string): ExtensionHost;
 }
 /**
  * Expose a connector as an MCP server.
@@ -467,28 +223,36 @@ declare function createConnectorServer(connector: Connector, options?: Connector
 /** Serve a connector on stdio. This is the one line a connector's bin needs. */
 declare function serveConnector(connector: Connector, options?: ConnectorServerOptions): Promise<void>;
 
-interface HarnessOptions {
-    config?: ConnectorConfig;
-    /** Fixed clock, so `updatedAt` defaults and cursors are deterministic. */
-    now?: () => string;
-}
-interface ConnectorHarness {
-    poll(triggerType: string, options?: RunPollOptions): Promise<PollPage>;
-    drain(triggerType: string, options?: RunPollOptions): Promise<NormalizedItem[]>;
-    execute(actionType: string, args?: Record<string, unknown>): Promise<Record<string, unknown>>;
-    manifest(): ConnectorManifest;
-    /**
-     * Poll repeatedly the way Vorn does — carrying the newest `updatedAt`
-     * forward as the watermark — and return only items a real installation
-     * would treat as new. Catches the classic connector bug where a poll
-     * ignores its lower bound and re-delivers the same backlog forever.
-     */
-    pollTwice(triggerType: string, options?: RunPollOptions): Promise<NormalizedItem[]>;
-}
 /**
- * Run a connector in-process, exactly as the MCP server would, without
- * spawning anything. Authors get real assertions in a plain unit test.
+ * The files a new connector starts as.
+ *
+ * A connector is mostly boilerplate — a package that builds, an entry that
+ * serves, a definition, a test that proves it without a network — and getting
+ * that boilerplate right is the slowest part of writing the interesting bit.
+ * Generating it means every connector starts from the same shape, which is
+ * also the shape `check` and `pack` expect to find.
+ *
+ * The files are returned rather than written so the decision of what to write
+ * stays testable, and the writing stays in the CLI.
  */
-declare function createConnectorHarness(connector: Connector, harnessOptions?: HarnessOptions): ConnectorHarness;
+interface ScaffoldOptions {
+    id: string;
+    /** Defaults to the id in title case. */
+    name?: string;
+    description?: string;
+    /** Emit the shape the connectors repository expects of a package inside it. */
+    repoConventions?: boolean;
+    /** What to start: a connector that polls a service, or an extension that contributes to a card. */
+    kind?: 'connector' | 'extension';
+}
+interface ScaffoldFile {
+    /** Relative to the directory the connector is created in. */
+    path: string;
+    contents: string;
+}
+/** `acme-tickets` → `Acme Tickets`, so a generated name reads like a name. */
+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 { type ActionContext, type ActionDefinition, type ActionInputField, type CheckFinding, type CheckOptions, type ConnectionSetup, type Connector, type ConnectorConfig, type ConnectorConfigField, type ConnectorDefinition, type ConnectorHarness, type ConnectorIcon, type ConnectorItem, type ConnectorManifest, type ConnectorServerOptions, type DedupeStrategy, type DefaultWorkflow, type FetchContext, type HarnessOptions, MANIFEST_TOOL, MAX_POLL_PAGES, type NormalizedItem, PREFLIGHT_TOOL, type PollContext, type PollOutcome, type PollPage, type PreflightResult, type RunActionOptions, type RunPollOptions, type StatusSuggestion, type TriggerDefinition, checkConnector, connectionSetup, connectorManifest, createConnectorHarness, createConnectorServer, defineConnector, drainPoll, envNameFor, formatFindings, normalizeItem, normalizeItems, pollToolName, pollWithDedupe, resolveConfig, runAction, runPoll, serveConnector };
+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 };