@vornrun/connector-sdk 0.7.0-beta.13 → 0.7.0-beta.14

package/dist/{chunk-XOP6JKBX.js → chunk-PMMEWBVK.js}

@@ -1,6 +1,264 @@
+// 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 ABSOLUTE_URL_PATTERN = /^https?:\/\//i;
+var CONFIG_ROOTED_URL_PATTERN = /^\{\{\s*config\./;
+function assertUnique(kind, keys) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    if (seen.has(key)) throw new Error(`Duplicate ${kind} "${key}"`);
+    seen.add(key);
+  }
+}
+function assertAuth(definition) {
+  const auth = definition.auth;
+  if (!auth) return;
+  const id = definition.id;
+  if (!AUTH_RUNGS.includes(auth.rung)) {
+    throw new Error(
+      `Connector ${id} declares unknown auth rung ${JSON.stringify(auth.rung)}; expected ${AUTH_RUNGS.join(", ")}`
+    );
+  }
+  if (auth.rung === "cli" && !auth.probe?.command?.trim()) {
+    throw new Error(`Connector ${id} borrows a CLI login but declares no probe command to ask it`);
+  }
+  if (auth.rung === "key") {
+    const keys = auth.keys ?? [];
+    if (keys.length === 0) {
+      throw new Error(`Connector ${id} signs in with a key but names no config field holding it`);
+    }
+    const declared = new Set((definition.config ?? []).map((field) => field.key));
+    for (const key of keys) {
+      if (!declared.has(key)) {
+        throw new Error(`Connector ${id} names auth key "${key}", which is not a config field`);
+      }
+    }
+  }
+  if (auth.rung === "none") {
+    const secret = (definition.config ?? []).find((field) => field.secret === true);
+    if (secret) {
+      throw new Error(
+        `Connector ${id} claims it needs no sign-in but declares secret field "${secret.key}"`
+      );
+    }
+  }
+}
+function envNameFor(key, explicit) {
+  if (explicit) return explicit;
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function defineConnector(definition) {
+  if (!KEY_PATTERN.test(definition.id ?? "")) {
+    throw new Error(`Connector id "${definition.id}" must start with a letter and be url-safe`);
+  }
+  if (!definition.name?.trim()) {
+    throw new Error(`Connector ${definition.id} is missing a name`);
+  }
+  if (definition.icon) {
+    const { viewBox, paths } = definition.icon;
+    if (!Array.isArray(paths) || paths.length === 0) {
+      throw new Error(`Connector ${definition.id} has an icon with no paths`);
+    }
+    for (const path of paths) {
+      if (typeof path !== "string" || !PATH_DATA_PATTERN.test(path)) {
+        throw new Error(
+          `Connector ${definition.id} has an icon path that is not SVG path data. Only path data is accepted, not markup.`
+        );
+      }
+    }
+    if (viewBox !== void 0 && !VIEW_BOX_PATTERN.test(viewBox)) {
+      throw new Error(`Connector ${definition.id} has an icon viewBox that is not four numbers`);
+    }
+  }
+  const triggers = definition.triggers ?? [];
+  const actions = definition.actions ?? [];
+  if (triggers.length === 0 && actions.length === 0) {
+    throw new Error(`Connector ${definition.id} declares no triggers and no actions`);
+  }
+  for (const trigger of triggers) {
+    if (!KEY_PATTERN.test(trigger.type ?? "")) {
+      throw new Error(`Trigger type "${trigger.type}" must start with a letter and be url-safe`);
+    }
+    const loose = trigger;
+    const declarative = typeof loose.fetch === "function";
+    const imperative = typeof loose.poll === "function";
+    if (declarative && imperative) {
+      throw new Error(`Trigger ${trigger.type} declares both fetch() and poll(); pick one`);
+    }
+    if (declarative !== (loose.dedupe !== void 0)) {
+      throw new Error(
+        `Trigger ${trigger.type} needs fetch() and a dedupe strategy together, not one alone`
+      );
+    }
+    if (loose.dedupe !== void 0 && !DEDUPE_STRATEGIES.includes(loose.dedupe)) {
+      throw new Error(
+        `Trigger ${trigger.type} has unknown dedupe strategy ${JSON.stringify(loose.dedupe)}; expected ${DEDUPE_STRATEGIES.join(" or ")}`
+      );
+    }
+    if (loose.poll !== void 0 && !imperative) {
+      throw new Error(`Trigger ${trigger.type} declares poll but it is not a function`);
+    }
+    if (!declarative && !imperative) {
+      throw new Error(`Trigger ${trigger.type} is missing a fetch() or poll() implementation`);
+    }
+  }
+  for (const action of actions) {
+    if (!KEY_PATTERN.test(action.type ?? "")) {
+      throw new Error(`Action type "${action.type}" must start with a letter and be url-safe`);
+    }
+    const loose = action;
+    const written = typeof loose.run === "function";
+    const declared = loose.request !== void 0;
+    if (written && declared) {
+      throw new Error(`Action ${action.type} declares both run() and a request; pick one`);
+    }
+    if (!written && !declared) {
+      throw new Error(`Action ${action.type} is missing a run() implementation or a request`);
+    }
+    if (declared) {
+      const request = loose.request;
+      if (typeof request?.url !== "string" || request.url.trim() === "") {
+        throw new Error(`Action ${action.type} declares a request with no URL`);
+      }
+      const url = request.url.trim();
+      if (!ABSOLUTE_URL_PATTERN.test(url) && !CONFIG_ROOTED_URL_PATTERN.test(url)) {
+        throw new Error(
+          `Action ${action.type} declares the request URL "${url}", which is neither absolute nor rooted in a {{config.\u2026}} value`
+        );
+      }
+    }
+    if (!declared && loose.postReceive !== void 0) {
+      throw new Error(`Action ${action.type} has postReceive but no request for it to reshape`);
+    }
+    for (const input of action.inputs ?? []) {
+      if (input.loadOptions !== void 0 && definition.options?.[input.loadOptions] === void 0) {
+        throw new Error(
+          `Action ${action.type} argument "${input.key}" loads options from "${input.loadOptions}", which the connector does not serve`
+        );
+      }
+    }
+  }
+  assertUnique(
+    "trigger",
+    triggers.map((trigger) => trigger.type)
+  );
+  assertUnique(
+    "action",
+    actions.map((action) => action.type)
+  );
+  assertUnique(
+    "config field",
+    (definition.config ?? []).map((field) => field.key)
+  );
+  assertAuth(definition);
+  return {
+    ...definition,
+    version: definition.version ?? "0.0.0",
+    config: definition.config ?? [],
+    triggers,
+    actions
+  };
+}
+function resolveConfig(connector, env = process.env) {
+  const config = {};
+  const missing = [];
+  for (const field of connector.config) {
+    const name = envNameFor(field.key, field.env);
+    const value = env[name] ?? field.default;
+    if (value === void 0 || value === "") {
+      if (field.required) missing.push(`${field.key} (${name})`);
+      continue;
+    }
+    config[field.key] = value;
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Connector ${connector.id} is missing required configuration: ${missing.join(", ")}`
+    );
+  }
+  return config;
+}
+
+// src/setup.ts
+function pollToolName(triggerType) {
+  return `poll_${triggerType}`;
+}
+var MANIFEST_TOOL = "vorn_connector_manifest";
+var PREFLIGHT_TOOL = "vorn_connector_preflight";
+var OPTIONS_TOOL = "vorn_connector_options";
+function connectionSetup(connector, triggerType) {
+  const trigger = connector.triggers.find((entry) => entry.type === triggerType);
+  if (!trigger) {
+    throw new Error(`Connector ${connector.id} has no trigger "${triggerType}"`);
+  }
+  return {
+    connectorId: connector.id,
+    triggerType,
+    filters: {
+      pollTool: pollToolName(triggerType),
+      itemsPath: "items",
+      idField: "externalId",
+      timestampField: "updatedAt",
+      titleField: "title",
+      urlField: "url",
+      cursorArg: "cursor",
+      cursorPath: "nextCursor"
+    },
+    env: connector.config.map((field) => ({
+      name: envNameFor(field.key, field.env),
+      required: field.required === true,
+      secret: field.secret === true,
+      ...field.description !== void 0 && { description: field.description },
+      ...field.builderHint !== void 0 && { builderHint: field.builderHint }
+    }))
+  };
+}
+function connectorManifest(connector) {
+  return {
+    id: connector.id,
+    name: connector.name,
+    version: connector.version,
+    ...connector.description !== void 0 && { description: connector.description },
+    ...connector.icon !== void 0 && { icon: connector.icon },
+    ...connector.auth !== void 0 && { auth: connector.auth },
+    triggers: connector.triggers.map((trigger) => ({
+      type: trigger.type,
+      label: trigger.label,
+      ...trigger.description !== void 0 && { description: trigger.description },
+      // Carried through so the app can seed a connection's status mapping and
+      // its polling workflow. Absent when the connector said nothing, which is
+      // different from saying there is nothing.
+      ...trigger.statusMapping !== void 0 && { statusMapping: trigger.statusMapping },
+      ...trigger.defaultWorkflow !== void 0 && { defaultWorkflow: trigger.defaultWorkflow },
+      setup: connectionSetup(connector, trigger.type)
+    })),
+    actions: connector.actions.map((action) => ({
+      type: action.type,
+      label: action.label,
+      ...action.description !== void 0 && { description: action.description },
+      inputs: (action.inputs ?? []).map((input) => ({
+        key: input.key,
+        label: input.label,
+        type: input.type ?? "string",
+        required: input.required === true,
+        ...input.options !== void 0 && { options: input.options },
+        ...input.loadOptions !== void 0 && { loadOptions: input.loadOptions },
+        ...input.builderHint !== void 0 && { builderHint: input.builderHint }
+      })),
+      ...action.outputs !== void 0 && { outputs: action.outputs },
+      ...action.sample !== void 0 && { sample: action.sample }
+    }))
+  };
+}
+
 // src/packaging.ts
 import { builtinModules } from "module";
 import { readFileSync } from "fs";
+import { mkdtemp, writeFile } from "fs/promises";
+import { tmpdir } from "os";
 import { dirname, isAbsolute, join, resolve } from "path";
 var MAX_PACK_BYTES = 8 * 1024 * 1024;
 var LIFECYCLE_SCRIPTS = [
@@ -13,8 +271,8 @@ var LIFECYCLE_SCRIPTS = [
   "postpublish"
 ];
 var BUILTINS = new Set(builtinModules);
-function finding(code, target, message) {
-  return { level: "error", code, target, message };
+function finding(code, target, message, level = "error") {
+  return { level, code, target, message };
 }
 function lifecycleScriptFindings(pkg) {
   const scripts = pkg?.scripts;
@@ -45,6 +303,120 @@ function bundleDependencyFindings(external) {
     )
   ];
 }
+var RELATIVE_REQUIRE = /(?:__)?(?:require(?:\.resolve)?|import)\(\s*(['"])(\.\.?\/[^'"]*)\1\s*\)/y;
+var RELATIVE_CREATE_REQUIRE = /createRequire\([^()]*\)\(\s*(['"])(\.\.?\/[^'"]*)\1\s*\)/y;
+var CALL_WORDS = /* @__PURE__ */ new Set(["require", "__require", "createRequire", "import"]);
+var BEFORE_REGEX = /* @__PURE__ */ new Set(["", ..."(,=:[!&|?{};+-*%~^<>"]);
+var BEFORE_REGEX_WORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+var WORD = /[\w$]/;
+function endOfQuoted(code, start) {
+  const quote2 = code[start];
+  let i = start + 1;
+  while (i < code.length) {
+    if (code[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (code[i] === quote2) return i + 1;
+    i += 1;
+  }
+  return code.length;
+}
+function endOfRegex(code, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") return i;
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) return i + 1;
+    i += 1;
+  }
+  return code.length;
+}
+function relativeRuntimeSpecifiers(code) {
+  const found = /* @__PURE__ */ new Set();
+  let previous = "";
+  let previousWord = "";
+  let i = 0;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "/" && code[i + 1] === "/") {
+      const end = code.indexOf("\n", i);
+      i = end === -1 ? code.length : end;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      i = end === -1 ? code.length : end + 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      i = endOfQuoted(code, i);
+      previous = ch;
+      previousWord = "";
+      continue;
+    }
+    if (ch === "/" && (BEFORE_REGEX.has(previous) || BEFORE_REGEX_WORDS.has(previousWord))) {
+      i = endOfRegex(code, i);
+      previous = "/";
+      previousWord = "";
+      continue;
+    }
+    if (WORD.test(ch)) {
+      const start = i;
+      while (i < code.length && WORD.test(code[i])) i += 1;
+      const word = code.slice(start, i);
+      if (CALL_WORDS.has(word) && code[start - 1] !== ".") {
+        for (const pattern of [RELATIVE_REQUIRE, RELATIVE_CREATE_REQUIRE]) {
+          pattern.lastIndex = start;
+          const match = pattern.exec(code);
+          if (match) found.add(match[2]);
+        }
+      }
+      previous = code[i - 1];
+      previousWord = word;
+      continue;
+    }
+    if (!/\s/.test(ch)) {
+      previous = ch;
+      previousWord = "";
+    }
+    i += 1;
+  }
+  return [...found];
+}
+function bundledRequireFindings(code) {
+  const specifiers = relativeRuntimeSpecifiers(code);
+  if (specifiers.length === 0) return [];
+  return [
+    finding(
+      "runtime-dependencies",
+      "bundle",
+      `${specifiers.sort().join(", ")} ${specifiers.length === 1 ? "is" : "are"} required at runtime; a pack is one file, so nothing beside it survives packing`,
+      "warn"
+    )
+  ];
+}
 function packageDirFor(resolveDir, entry) {
   const from = resolve(resolveDir);
   if (entry === void 0) return from;
@@ -72,6 +444,100 @@ function packEntryContents(entry, sdkModule = "@vornrun/connector-sdk") {
     ""
   ].join("\n");
 }
+async function stagePack(connector, code) {
+  const dir = await mkdtemp(join(tmpdir(), "vorn-pack-"));
+  await writeFile(join(dir, "index.js"), code, "utf8");
+  await writeFile(
+    join(dir, "manifest.json"),
+    `${JSON.stringify(connectorManifest(connector), null, 2)}
+`,
+    "utf8"
+  );
+  return dir;
+}
+var LAUNCH_TIMEOUT_MS = 15e3;
+var LAUNCH_ENV_KEYS = [
+  "PATH",
+  "HOME",
+  "USERPROFILE",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "PROGRAMDATA",
+  "PROGRAMFILES",
+  "SystemRoot",
+  "SYSTEMDRIVE",
+  "COMSPEC",
+  "PATHEXT",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TZ",
+  "SHELL",
+  "TERM",
+  "USER",
+  "LOGNAME",
+  "NODE_EXTRA_CA_CERTS"
+];
+function launchEnv() {
+  const env = {};
+  for (const key of LAUNCH_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  return env;
+}
+function errorLine(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  return [...lines].reverse().find((line) => /Error\b/.test(line)) ?? lines[lines.length - 1];
+}
+function withTimeout(promise, ms, message) {
+  let timer;
+  return Promise.race([
+    promise.finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), ms);
+    })
+  ]);
+}
+async function packLaunchFindings(dir) {
+  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: ["index.js"],
+    cwd: dir,
+    env: launchEnv(),
+    stderr: "pipe"
+  });
+  const client = new Client({ name: "vorn-connector-check", version: "1" }, { capabilities: {} });
+  let stderr = "";
+  transport.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  try {
+    await withTimeout(
+      client.connect(transport),
+      LAUNCH_TIMEOUT_MS,
+      `did not answer within ${LAUNCH_TIMEOUT_MS / 1e3}s of starting`
+    );
+    return [];
+  } catch (error) {
+    const said = error instanceof Error ? error.message : String(error);
+    return [
+      finding("pack-launch", "bundle", `did not start as a pack: ${errorLine(stderr) ?? said}`)
+    ];
+  } finally {
+    await client.close().catch(() => {
+    });
+    await transport.close().catch(() => {
+    });
+  }
+}
 async function esbuildBundle(request) {
   const { build } = await import("esbuild");
   const result = await build({
@@ -87,7 +553,15 @@ async function esbuildBundle(request) {
     format: "esm",
     write: false,
     metafile: true,
-    legalComments: "none"
+    legalComments: "none",
+    // A bundled CommonJS dependency asks for its builtins through esbuild's shim, which throws unless a real require is in scope.
+    banner: {
+      js: [
+        "import { createRequire as __vornCreateRequire } from 'node:module'",
+        "const require = __vornCreateRequire(import.meta.url)",
+        ""
+      ].join("\n")
+    }
   });
   const output = Object.values(result.metafile.outputs)[0];
   return {
@@ -681,336 +1155,80 @@ function quote(value) {
 }
 function coerceArg(value, type) {
   if (typeof value !== "string") return value;
-  if (type === "number") {
-    const parsed = Number(value);
-    if (Number.isNaN(parsed)) throw new Error(`Expected a number, got "${quote(value)}"`);
-    return parsed;
-  }
-  if (type === "boolean") {
-    if (value === "true") return true;
-    if (value === "false") return false;
-    throw new Error(`Expected a boolean, got "${quote(value)}"`);
-  }
-  if (type === "json") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      throw new Error(`Expected JSON, got "${quote(value)}"`);
-    }
-  }
-  return value;
-}
-async function runAction(connector, actionType, args, options = {}) {
-  const action = connector.actions.find((entry) => entry.type === actionType);
-  if (!action) {
-    throw new Error(`Connector ${connector.id} has no action "${actionType}"`);
-  }
-  const coerced = { ...args };
-  for (const input of action.inputs ?? []) {
-    const value = coerced[input.key];
-    if (value === void 0 || value === "") {
-      if (input.required) throw new Error(`Action ${actionType} requires "${input.key}"`);
-      delete coerced[input.key];
-      continue;
-    }
-    try {
-      coerced[input.key] = coerceArg(value, input.type);
-    } catch (error) {
-      throw new Error(
-        `Action ${actionType} argument "${input.key}": ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error }
-      );
-    }
-  }
-  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 }
-  });
-  if (action.request !== void 0) {
-    try {
-      return await executeRequest(
-        action.request,
-        action.postReceive,
-        { args: coerced, config },
-        { fetchImpl }
-      );
-    } catch (error) {
-      throw new Error(
-        `Action ${actionType}: ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error }
-      );
-    }
-  }
-  if (typeof action.run !== "function") {
-    throw new Error(`Action ${actionType} has neither a run() implementation nor a request`);
-  }
-  const output = await action.run(coerced, {
-    config,
-    now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
-    fetch: fetchImpl
-  });
-  return output ?? {};
-}
-
-// 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 ABSOLUTE_URL_PATTERN = /^https?:\/\//i;
-var CONFIG_ROOTED_URL_PATTERN = /^\{\{\s*config\./;
-function assertUnique(kind, keys) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const key of keys) {
-    if (seen.has(key)) throw new Error(`Duplicate ${kind} "${key}"`);
-    seen.add(key);
-  }
-}
-function assertAuth(definition) {
-  const auth = definition.auth;
-  if (!auth) return;
-  const id = definition.id;
-  if (!AUTH_RUNGS.includes(auth.rung)) {
-    throw new Error(
-      `Connector ${id} declares unknown auth rung ${JSON.stringify(auth.rung)}; expected ${AUTH_RUNGS.join(", ")}`
-    );
-  }
-  if (auth.rung === "cli" && !auth.probe?.command?.trim()) {
-    throw new Error(`Connector ${id} borrows a CLI login but declares no probe command to ask it`);
-  }
-  if (auth.rung === "key") {
-    const keys = auth.keys ?? [];
-    if (keys.length === 0) {
-      throw new Error(`Connector ${id} signs in with a key but names no config field holding it`);
-    }
-    const declared = new Set((definition.config ?? []).map((field) => field.key));
-    for (const key of keys) {
-      if (!declared.has(key)) {
-        throw new Error(`Connector ${id} names auth key "${key}", which is not a config field`);
-      }
-    }
-  }
-  if (auth.rung === "none") {
-    const secret = (definition.config ?? []).find((field) => field.secret === true);
-    if (secret) {
-      throw new Error(
-        `Connector ${id} claims it needs no sign-in but declares secret field "${secret.key}"`
-      );
-    }
-  }
-}
-function envNameFor(key, explicit) {
-  if (explicit) return explicit;
-  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
-}
-function defineConnector(definition) {
-  if (!KEY_PATTERN.test(definition.id ?? "")) {
-    throw new Error(`Connector id "${definition.id}" must start with a letter and be url-safe`);
-  }
-  if (!definition.name?.trim()) {
-    throw new Error(`Connector ${definition.id} is missing a name`);
-  }
-  if (definition.icon) {
-    const { viewBox, paths } = definition.icon;
-    if (!Array.isArray(paths) || paths.length === 0) {
-      throw new Error(`Connector ${definition.id} has an icon with no paths`);
-    }
-    for (const path of paths) {
-      if (typeof path !== "string" || !PATH_DATA_PATTERN.test(path)) {
-        throw new Error(
-          `Connector ${definition.id} has an icon path that is not SVG path data. Only path data is accepted, not markup.`
-        );
-      }
-    }
-    if (viewBox !== void 0 && !VIEW_BOX_PATTERN.test(viewBox)) {
-      throw new Error(`Connector ${definition.id} has an icon viewBox that is not four numbers`);
-    }
+  if (type === "number") {
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) throw new Error(`Expected a number, got "${quote(value)}"`);
+    return parsed;
   }
-  const triggers = definition.triggers ?? [];
-  const actions = definition.actions ?? [];
-  if (triggers.length === 0 && actions.length === 0) {
-    throw new Error(`Connector ${definition.id} declares no triggers and no actions`);
+  if (type === "boolean") {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    throw new Error(`Expected a boolean, got "${quote(value)}"`);
   }
-  for (const trigger of triggers) {
-    if (!KEY_PATTERN.test(trigger.type ?? "")) {
-      throw new Error(`Trigger type "${trigger.type}" must start with a letter and be url-safe`);
+  if (type === "json") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new Error(`Expected JSON, got "${quote(value)}"`);
     }
-    const loose = trigger;
-    const declarative = typeof loose.fetch === "function";
-    const imperative = typeof loose.poll === "function";
-    if (declarative && imperative) {
-      throw new Error(`Trigger ${trigger.type} declares both fetch() and poll(); pick one`);
+  }
+  return value;
+}
+async function runAction(connector, actionType, args, options = {}) {
+  const action = connector.actions.find((entry) => entry.type === actionType);
+  if (!action) {
+    throw new Error(`Connector ${connector.id} has no action "${actionType}"`);
+  }
+  const coerced = { ...args };
+  for (const input of action.inputs ?? []) {
+    const value = coerced[input.key];
+    if (value === void 0 || value === "") {
+      if (input.required) throw new Error(`Action ${actionType} requires "${input.key}"`);
+      delete coerced[input.key];
+      continue;
     }
-    if (declarative !== (loose.dedupe !== void 0)) {
+    try {
+      coerced[input.key] = coerceArg(value, input.type);
+    } catch (error) {
       throw new Error(
-        `Trigger ${trigger.type} needs fetch() and a dedupe strategy together, not one alone`
+        `Action ${actionType} argument "${input.key}": ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
-    if (loose.dedupe !== void 0 && !DEDUPE_STRATEGIES.includes(loose.dedupe)) {
+  }
+  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 }
+  });
+  if (action.request !== void 0) {
+    try {
+      return await executeRequest(
+        action.request,
+        action.postReceive,
+        { args: coerced, config },
+        { fetchImpl }
+      );
+    } catch (error) {
       throw new Error(
-        `Trigger ${trigger.type} has unknown dedupe strategy ${JSON.stringify(loose.dedupe)}; expected ${DEDUPE_STRATEGIES.join(" or ")}`
+        `Action ${actionType}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
-    if (loose.poll !== void 0 && !imperative) {
-      throw new Error(`Trigger ${trigger.type} declares poll but it is not a function`);
-    }
-    if (!declarative && !imperative) {
-      throw new Error(`Trigger ${trigger.type} is missing a fetch() or poll() implementation`);
-    }
-  }
-  for (const action of actions) {
-    if (!KEY_PATTERN.test(action.type ?? "")) {
-      throw new Error(`Action type "${action.type}" must start with a letter and be url-safe`);
-    }
-    const loose = action;
-    const written = typeof loose.run === "function";
-    const declared = loose.request !== void 0;
-    if (written && declared) {
-      throw new Error(`Action ${action.type} declares both run() and a request; pick one`);
-    }
-    if (!written && !declared) {
-      throw new Error(`Action ${action.type} is missing a run() implementation or a request`);
-    }
-    if (declared) {
-      const request = loose.request;
-      if (typeof request?.url !== "string" || request.url.trim() === "") {
-        throw new Error(`Action ${action.type} declares a request with no URL`);
-      }
-      const url = request.url.trim();
-      if (!ABSOLUTE_URL_PATTERN.test(url) && !CONFIG_ROOTED_URL_PATTERN.test(url)) {
-        throw new Error(
-          `Action ${action.type} declares the request URL "${url}", which is neither absolute nor rooted in a {{config.\u2026}} value`
-        );
-      }
-    }
-    if (!declared && loose.postReceive !== void 0) {
-      throw new Error(`Action ${action.type} has postReceive but no request for it to reshape`);
-    }
-    for (const input of action.inputs ?? []) {
-      if (input.loadOptions !== void 0 && definition.options?.[input.loadOptions] === void 0) {
-        throw new Error(
-          `Action ${action.type} argument "${input.key}" loads options from "${input.loadOptions}", which the connector does not serve`
-        );
-      }
-    }
-  }
-  assertUnique(
-    "trigger",
-    triggers.map((trigger) => trigger.type)
-  );
-  assertUnique(
-    "action",
-    actions.map((action) => action.type)
-  );
-  assertUnique(
-    "config field",
-    (definition.config ?? []).map((field) => field.key)
-  );
-  assertAuth(definition);
-  return {
-    ...definition,
-    version: definition.version ?? "0.0.0",
-    config: definition.config ?? [],
-    triggers,
-    actions
-  };
-}
-function resolveConfig(connector, env = process.env) {
-  const config = {};
-  const missing = [];
-  for (const field of connector.config) {
-    const name = envNameFor(field.key, field.env);
-    const value = env[name] ?? field.default;
-    if (value === void 0 || value === "") {
-      if (field.required) missing.push(`${field.key} (${name})`);
-      continue;
-    }
-    config[field.key] = value;
-  }
-  if (missing.length > 0) {
-    throw new Error(
-      `Connector ${connector.id} is missing required configuration: ${missing.join(", ")}`
-    );
   }
-  return config;
-}
-
-// src/setup.ts
-function pollToolName(triggerType) {
-  return `poll_${triggerType}`;
-}
-var MANIFEST_TOOL = "vorn_connector_manifest";
-var PREFLIGHT_TOOL = "vorn_connector_preflight";
-var OPTIONS_TOOL = "vorn_connector_options";
-function connectionSetup(connector, triggerType) {
-  const trigger = connector.triggers.find((entry) => entry.type === triggerType);
-  if (!trigger) {
-    throw new Error(`Connector ${connector.id} has no trigger "${triggerType}"`);
+  if (typeof action.run !== "function") {
+    throw new Error(`Action ${actionType} has neither a run() implementation nor a request`);
   }
-  return {
-    connectorId: connector.id,
-    triggerType,
-    filters: {
-      pollTool: pollToolName(triggerType),
-      itemsPath: "items",
-      idField: "externalId",
-      timestampField: "updatedAt",
-      titleField: "title",
-      urlField: "url",
-      cursorArg: "cursor",
-      cursorPath: "nextCursor"
-    },
-    env: connector.config.map((field) => ({
-      name: envNameFor(field.key, field.env),
-      required: field.required === true,
-      secret: field.secret === true,
-      ...field.description !== void 0 && { description: field.description },
-      ...field.builderHint !== void 0 && { builderHint: field.builderHint }
-    }))
-  };
-}
-function connectorManifest(connector) {
-  return {
-    id: connector.id,
-    name: connector.name,
-    version: connector.version,
-    ...connector.description !== void 0 && { description: connector.description },
-    ...connector.icon !== void 0 && { icon: connector.icon },
-    ...connector.auth !== void 0 && { auth: connector.auth },
-    triggers: connector.triggers.map((trigger) => ({
-      type: trigger.type,
-      label: trigger.label,
-      ...trigger.description !== void 0 && { description: trigger.description },
-      // Carried through so the app can seed a connection's status mapping and
-      // its polling workflow. Absent when the connector said nothing, which is
-      // different from saying there is nothing.
-      ...trigger.statusMapping !== void 0 && { statusMapping: trigger.statusMapping },
-      ...trigger.defaultWorkflow !== void 0 && { defaultWorkflow: trigger.defaultWorkflow },
-      setup: connectionSetup(connector, trigger.type)
-    })),
-    actions: connector.actions.map((action) => ({
-      type: action.type,
-      label: action.label,
-      ...action.description !== void 0 && { description: action.description },
-      inputs: (action.inputs ?? []).map((input) => ({
-        key: input.key,
-        label: input.label,
-        type: input.type ?? "string",
-        required: input.required === true,
-        ...input.options !== void 0 && { options: input.options },
-        ...input.loadOptions !== void 0 && { loadOptions: input.loadOptions },
-        ...input.builderHint !== void 0 && { builderHint: input.builderHint }
-      })),
-      ...action.outputs !== void 0 && { outputs: action.outputs },
-      ...action.sample !== void 0 && { sample: action.sample }
-    }))
-  };
+  const output = await action.run(coerced, {
+    config,
+    now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
+    fetch: fetchImpl
+  });
+  return output ?? {};
 }
 
 // src/harness.ts
@@ -1111,6 +1329,7 @@ function createConnectorHarness(connector, harnessOptions = {}) {
 }
 
 // src/check.ts
+import { rm } from "fs/promises";
 var EXECUTABLE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 var CREDENTIAL_NAME = /(secret|token|password|passphrase|api[-_]?key|credential)/i;
 var INPUT_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "select", "json"]);
@@ -1204,7 +1423,13 @@ function actionShapeFindings(action) {
   }
   return found;
 }
-async function packageFindings(options) {
+function bundles(options) {
+  return Boolean(options.bundle && options.entry !== void 0 && options.packageDir !== void 0);
+}
+function launches(options) {
+  return bundles(options) && options.mock === true;
+}
+async function packageFindings(connector, options) {
   if (options.packageDir === void 0) return [];
   const pkg = readNearestPackageJson(packageDirFor(options.packageDir, options.entry));
   const found = [...lifecycleScriptFindings(pkg)];
@@ -1225,7 +1450,15 @@ async function packageFindings(options) {
       contents: packEntryContents(options.entry),
       resolveDir: options.packageDir
     });
-    found.push(...bundleDependencyFindings(built.external));
+    found.push(...bundleDependencyFindings(built.external), ...bundledRequireFindings(built.code));
+    if (options.mock) {
+      const dir = await stagePack(connector, built.code);
+      try {
+        found.push(...await packLaunchFindings(dir));
+      } finally {
+        await rm(dir, { recursive: true, force: true });
+      }
+    }
   }
   return found;
 }
@@ -1420,7 +1653,7 @@ async function checkConnector(connector, options = {}) {
   }
   found.push(...authFindings(connector));
   found.push(...secretFindings(connector));
-  found.push(...await packageFindings(options));
+  found.push(...await packageFindings(connector, options));
   found.push(...await mockFindings(connector, options));
   found.push(...await liveFindings(connector, options));
   const perTrigger = await Promise.all(
@@ -1516,7 +1749,8 @@ var CHECK_OWNERS = {
   "mock-network-escape": "mock",
   "mock-not-observed": "mock",
   "preflight-failed": "live",
-  "live-action-failed": "live"
+  "live-action-failed": "live",
+  "pack-launch": "launch"
 };
 function checksRun(connector, options) {
   const names = ["manifest", "auth"];
@@ -1524,7 +1758,8 @@ function checksRun(connector, options) {
   if (connector.actions.length > 0) names.push("actions");
   if (connector.triggers.length > 0) names.push("dedupe");
   if (options.packageDir !== void 0) names.push("no-lifecycle-scripts", "keywords");
-  if (options.bundle && options.entry !== void 0) names.push("no-runtime-deps");
+  if (bundles(options)) names.push("no-runtime-deps");
+  if (launches(options)) names.push("launch");
   if (options.mock && connector.actions.length > 0) names.push("mock");
   if (options.live && liveExamines(connector)) names.push("live");
   return names;
@@ -1555,8 +1790,7 @@ function formatFindings(findings) {
 }
 
 // src/pack.ts
-import { mkdtemp, mkdir, rm, stat, writeFile } from "fs/promises";
-import { tmpdir } from "os";
+import { mkdir, rm as rm2, stat } from "fs/promises";
 import { join as join2, resolve as resolve2 } from "path";
 function finding3(code, target, message) {
   return { level: "error", code, target, message };
@@ -1573,29 +1807,24 @@ async function packConnector(connector, options) {
   const contents = packEntryContents(options.entry, options.sdkModule);
   const bundle = options.bundle ?? esbuildBundle;
   const built = await bundle({ contents, resolveDir });
-  findings.push(...bundleDependencyFindings(built.external));
+  findings.push(...bundleDependencyFindings(built.external), ...bundledRequireFindings(built.code));
   if (findings.some((item) => item.level === "error")) return { findings };
   const outDir = resolve2(options.outDir ?? process.cwd());
   await mkdir(outDir, { recursive: true });
   const file = join2(outDir, packFileName(connector));
-  const staging = await mkdtemp(join2(tmpdir(), "vorn-pack-"));
+  const staging = await stagePack(connector, built.code);
   try {
-    await writeFile(join2(staging, "index.js"), built.code, "utf8");
-    await writeFile(
-      join2(staging, "manifest.json"),
-      `${JSON.stringify(connectorManifest(connector), null, 2)}
-`,
-      "utf8"
-    );
+    findings.push(...await (options.launch ?? packLaunchFindings)(staging));
+    if (findings.some((item) => item.level === "error")) return { findings };
     const { create } = await import("tar");
     await create({ gzip: true, file, cwd: staging }, ["manifest.json", "index.js"]);
   } finally {
-    await rm(staging, { recursive: true, force: true });
+    await rm2(staging, { recursive: true, force: true });
   }
   const bytes = (await stat(file)).size;
   const maxBytes = options.maxBytes ?? MAX_PACK_BYTES;
   if (bytes > maxBytes) {
-    await rm(file, { force: true });
+    await rm2(file, { force: true });
     return {
       findings: [
         ...findings,
@@ -1663,7 +1892,7 @@ function packageJson(id, description, inRepo) {
     }
   });
 }
-function tsconfig() {
+function tsconfig(inRepo) {
   return jsonFile({
     compilerOptions: {
       target: "ES2022",
@@ -1676,10 +1905,11 @@ function tsconfig() {
       skipLibCheck: true,
       types: ["node"],
       noEmit: true,
+      resolveJsonModule: true,
       ignoreDeprecations: "6.0",
       allowImportingTsExtensions: true
     },
-    include: ["src/**/*", "vitest.config.ts"]
+    include: ["src/**/*", ...inRepo ? ["vitest.config.ts"] : []]
   });
 }
 function tsupConfig() {
@@ -1712,12 +1942,14 @@ function changelog() {
 }
 function connectorSource(id, name, description) {
   return `import { defineConnector } from '@vornrun/connector-sdk'
+// Bundled at build time: a pack is one file, so a version read from disk is not there to read.
+import pkg from '../package.json'
 
 export const connector = defineConnector({
   id: ${JSON.stringify(id)},
   name: ${JSON.stringify(name)},
   description: ${JSON.stringify(description)},
-  version: '${SCAFFOLD_VERSION}',
+  version: pkg.version,
   // Prefer a login the machine already has: { rung: 'cli', probe: { command: 'tool', args: ['auth', 'status'] } }
   auth: { rung: 'key', keys: ['apiToken'] },
   config: [
@@ -1971,9 +2203,10 @@ function scaffoldFiles(options) {
     { path: "src/connector.test.ts", contents: testSource(name) },
     { path: "src/entry.test.ts", contents: entryTestSource() },
     { path: "README.md", contents: readme(options.id, name, description) },
+    // Everywhere: the generated source imports its package.json, which needs resolveJsonModule to compile.
+    { path: "tsconfig.json", contents: tsconfig(inRepo) },
     ...inRepo ? [
       { path: "CHANGELOG.md", contents: changelog() },
-      { path: "tsconfig.json", contents: tsconfig() },
       { path: "tsup.config.ts", contents: tsupConfig() },
       { path: "vitest.config.ts", contents: vitestConfig() }
     ] : []
@@ -2170,9 +2403,19 @@ async function serveConnector(connector, options = {}) {
 }
 
 export {
+  envNameFor,
+  defineConnector,
+  resolveConfig,
+  pollToolName,
+  MANIFEST_TOOL,
+  PREFLIGHT_TOOL,
+  OPTIONS_TOOL,
+  connectionSetup,
+  connectorManifest,
   MAX_PACK_BYTES,
   lifecycleScriptFindings,
   bundleDependencyFindings,
+  bundledRequireFindings,
   readNearestPackageJson,
   esbuildBundle,
   normalizeItem,
@@ -2194,15 +2437,6 @@ export {
   drainPoll,
   runOptions,
   runAction,
-  envNameFor,
-  defineConnector,
-  resolveConfig,
-  pollToolName,
-  MANIFEST_TOOL,
-  PREFLIGHT_TOOL,
-  OPTIONS_TOOL,
-  connectionSetup,
-  connectorManifest,
   MockRouteMissError,
   escapedMockHttp,
   withMockHttp,