@zackbart/connecta 0.7.9 → 0.8.1

package/src/executor-result.ts

@@ -1,15 +1,15 @@
 import type { ExecuteResult } from "./types.js";
 
 /** ~6k tokens. Sandbox code should filter data down before returning. */
-export const MAX_EXECUTE_RESULT_CHARS = 24_000;
+const MAX_EXECUTE_RESULT_CHARS = 24_000;
 export const MAX_EXECUTE_LOG_CHARS = 4_000;
 
 function msg(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
 
-export function serializeExecuteValue(value: unknown): string {
-  const serialized = JSON.stringify(value, null, 2);
+function serializeExecuteValue(value: unknown): string {
+  const serialized = JSON.stringify(value);
   return serialized === undefined ? String(value) : serialized;
 }
 

package/src/executors/quickjs-child.ts

@@ -37,7 +37,11 @@ function send(message: ChildToParentMessage): void {
   process.send(message);
 }
 
-function provider(name: string, jobId: number): ExecutorProvider {
+function provider(
+  name: string,
+  jobId: number,
+  prelude?: string,
+): ExecutorProvider {
   const functions = new Proxy(
     Object.create(null) as ExecutorProvider["fns"],
     {
@@ -72,7 +76,7 @@ function provider(name: string, jobId: number): ExecutorProvider {
           : undefined,
     },
   );
-  return { name, fns: functions };
+  return { name, fns: functions, ...(prelude ? { prelude } : {}) };
 }
 
 function fixedTransportFailure(message: string): ExecutionPayload {
@@ -90,8 +94,8 @@ async function run(payload: RunPayload): Promise<void> {
   }
   activeJobId = payload.id;
   try {
-    const providers = payload.providerNames.map((name) =>
-      provider(name, payload.id),
+    const providers = payload.providers.map(({ name, prelude }) =>
+      provider(name, payload.id, prelude),
     );
     const raw = await executeQuickJs(
       payload.code,

package/src/executors/quickjs-protocol.ts

@@ -15,7 +15,7 @@ export const MAX_QUICKJS_HOST_RPC_BYTES = 256 * 1024;
 export interface RunPayload {
   id: number;
   code: string;
-  providerNames: string[];
+  providers: Array<{ name: string; prelude?: string }>;
   options: QuickJsRuntimeOptions;
 }
 

package/src/executors/quickjs-runtime.ts

@@ -88,7 +88,8 @@ function exceedsUtf8ByteLimit(value: string, limit: number): boolean {
 export function normalizeCode(code: string): string {
   let c = code.trim();
   const fence = /^```[\w-]*\s*\n([\s\S]*?)\n?```$/.exec(c);
-  if (fence) c = fence[1].trim();
+  const fencedCode = fence?.[1];
+  if (fencedCode !== undefined) c = fencedCode.trim();
   // Sniff for an existing function expression past any leading comments/blank
   // lines — models routinely prefix their code with a `//` or `/* */` note,
   // which would otherwise defeat the detection and wrap the whole thing.
@@ -122,6 +123,9 @@ function setupScript(providers: ExecutorProvider[]): string {
     const ns = JSON.stringify(p.name);
     lines.push(`globalThis[${ns}] = __namespace(${ns});`);
   }
+  for (const p of providers) {
+    if (p.prelude) lines.push(p.prelude);
+  }
   lines.push(`delete globalThis.__namespace;`);
   return lines.join("\n");
 }

package/src/executors/quickjs.ts

@@ -67,13 +67,13 @@ interface ActiveRun {
 }
 
 interface ChildSlot {
-  child?: ChildProcess;
-  ready?: Promise<void>;
-  resolveReady?: () => void;
-  rejectReady?: (error: Error) => void;
-  readyTimer?: ReturnType<typeof setTimeout>;
-  active?: ActiveRun;
-  expectedExit?: ChildProcess;
+  child?: ChildProcess | undefined;
+  ready?: Promise<void> | undefined;
+  resolveReady?: (() => void) | undefined;
+  rejectReady?: ((error: Error) => void) | undefined;
+  readyTimer?: ReturnType<typeof setTimeout> | undefined;
+  active?: ActiveRun | undefined;
+  expectedExit?: ChildProcess | undefined;
   consecutiveCrashes: number;
   notBefore: number;
 }
@@ -360,7 +360,10 @@ class QuickJsChildPool implements AdmittingExecutor {
         {
           id,
           code,
-          providerNames: providers.map((item) => item.name),
+          providers: providers.map((item) => ({
+            name: item.name,
+            ...(item.prelude ? { prelude: item.prelude } : {}),
+          })),
           options: this.runtimeOptions,
         } satisfies RunPayload,
         "QuickJS run payload",

package/src/favicon.ts

@@ -41,8 +41,8 @@ function buildIco(): Uint8Array {
       const pixel = pixels + (row * size + x) * 4;
       ico[pixel + 3] = opaque ? 255 : 0;
       if (!opaque) {
-        ico[mask + row * maskRowLength + Math.floor(x / 8)] |=
-          0x80 >> (x % 8);
+        const maskIndex = mask + row * maskRowLength + Math.floor(x / 8);
+        ico[maskIndex] = (ico[maskIndex] ?? 0) | (0x80 >> (x % 8));
       }
     }
   }

package/src/index.ts

@@ -6,12 +6,6 @@ import {
 import { Registry } from "./registry.js";
 import { createFetchHandler } from "./server.js";
 import { droppedBrandingUrls, droppedUiAuthUrls } from "./ui.js";
-import {
-  resolveToolkits,
-  validateToolkitBindings,
-  type Toolkit,
-  type ToolkitConfig,
-} from "./toolkits.js";
 import { memoryStorage } from "./storage/memory.js";
 import { CONNECTA_VERSION } from "./version.js";
 import {
@@ -20,11 +14,6 @@ import {
   withExecutorAdmission,
 } from "./executor-admission.js";
 import type { ActivityReadGate, ActivityStore } from "./activity.js";
-import type {
-  CredentialCheckResult,
-  CredentialHealthConfig,
-} from "./credential-health.js";
-import type { DeferredWork } from "./connector-scope.js";
 import type {
   Connector,
   ConnectaBranding,
@@ -50,28 +39,22 @@ export interface ConnectaActivityConfig {
   deploymentId?: string;
 }
 
-/** Operator-vault encryption and proactive credential-health tuning. */
+/** Operator-vault encryption. */
 export interface ConnectaCredentialsConfig {
   /**
    * Base64-encoded 32-byte AES key for credentials managed on /credentials.
    * Keep this in the runtime's secret store, never in KV or source control.
    */
   encryptionKey?: string;
-  /**
-   * Tuning for proactive credential liveness checks that let a connector's
-   * status flip to `auth_required` before an agent's call fails. Defaults: one
-   * check per connector per 15 minutes, four in flight, 30 seconds each,
-   * triggered opportunistically by inbound authenticated traffic.
-   *
-   * Optional even without an encryption key because downstream OAuth connectors
-   * manage their own grants. `Connecta.checkCredentials()` runs the same checks
-   * on demand for a Worker cron trigger or Node interval.
-   */
-  health?: CredentialHealthConfig;
 }
 
 /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
 export interface ConnectaDiscoveryConfig {
+  /**
+   * Maximum connector catalogs/status probes fetched at once by discovery
+   * operations. Default 4.
+   */
+  concurrency?: number;
   /** Tool-list cache TTL (seconds). Default 300. */
   catalogTtlSeconds?: number;
   /**
@@ -151,38 +134,6 @@ export interface ConnectaAdmissionConfig {
 
 export interface ConnectaConfig {
   connectors: Connector[];
-  /**
-   * Named scoped views over `connectors`, selected per client connection with
-   * `?toolkit=<name>` on the `/mcp` URL. One deployment belongs to one org;
-   * a toolkit is the slice of it a group of team members sees.
-   *
-   * ```ts
-   * toolkits: {
-   *   support: { connectors: ["zendesk", "notion"] },
-   *   exec: {
-   *     connectors: ["zendesk", "notion", "gmail"],
-   *     excludeTools: ["gmail.send_message"],
-   *   },
-   * }
-   * ```
-   *
-   * Inside a toolkit-scoped session every meta-tool behaves as if out-of-scope
-   * connectors and tools do not exist, and an out-of-scope address fails
-   * exactly as a nonexistent one does. No `?toolkit=` ⇒ the full registry, so
-   * adding toolkits changes nothing for connections that don't ask for one; an
-   * unknown name is an error, never a silent fallback.
-   *
-   * Selection is self-service until a toolkit is BOUND to an inbound identity:
-   * pass `toolkits` to an auth adapter — `bearerToken(secret, { toolkits:
-   * ["support"] })` — and that credential may open only those toolkits, and may
-   * not connect unscoped unless it also passes `unscoped: true`. An unbound
-   * identity keeps the self-service behavior.
-   *
-   * Definitions are validated at construction: an unknown connector id, an
-   * empty connector selection, an empty `includeTools`, a malformed tool
-   * address, or an address naming no tool on an in-code connector all throw.
-   */
-  toolkits?: ToolkitConfig;
   /** Inbound auth adapters. Includes bearerToken(...); omit for open (dev). */
   auth?: InboundAuth | InboundAuth[];
   /** KVStorage impl. Defaults to memoryStorage(). */
@@ -194,7 +145,7 @@ export interface ConnectaConfig {
   publicUrl?: string;
   /** Payload-free tool activity storage and operator-read policy. */
   activity?: ConnectaActivityConfig;
-  /** Operator credential vault and proactive liveness-check settings. */
+  /** Operator credential vault settings. */
   credentials?: ConnectaCredentialsConfig;
   /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
   discovery?: ConnectaDiscoveryConfig;
@@ -230,37 +181,6 @@ export interface Connecta {
   /** Web-standard fetch handler. Usable as `export default { fetch: connecta.fetch }`. */
   fetch: (request: Request, env?: unknown, ctx?: unknown) => Promise<Response>;
   registry: Registry;
-  /**
-   * Check the stored downstream credentials now — the scheduler-facing half of
-   * credential health (issue #24). Wire it to whatever timer the runtime has:
-   *
-   * ```ts
-   * // Cloudflare Workers (wrangler.jsonc: "triggers": { "crons": ["*\/15 * * * *"] })
-   * async scheduled(_c, env, ctx) {
-   *   const defer = ctx.waitUntil.bind(ctx);
-   *   ctx.waitUntil(build(env).checkCredentials({ defer }));
-   * }
-   * // Node
-   * setInterval(() => void connecta.checkCredentials(), 15 * 60_000).unref();
-   * ```
-   *
-   * Returns one outcome per connector considered, including why a connector was
-   * skipped (`fresh` is the rate limit: a connector checked less than
-   * `credentials.health.intervalSeconds` ago is not re-checked unless `force`).
-   * Never rejects on a connector failure — a broken connector becomes an `error`
-   * verdict. Needs a base URL for connector contexts: `publicUrl` supplies it,
-   * or pass one.
-   */
-  checkCredentials: (opts?: {
-    baseUrl?: string;
-    force?: boolean;
-    ids?: string[];
-    /**
-     * Runtime continuation for bounded teardown after the check result is ready.
-     * Workers should pass `ctx.waitUntil.bind(ctx)`.
-     */
-    defer?: DeferredWork;
-  }) => Promise<CredentialCheckResult[]>;
   /** Drain and release configured executor resources. Idempotent. */
   close: () => Promise<void>;
 }
@@ -313,7 +233,6 @@ const LEGACY_CONFIG_MIGRATIONS = [
   ["activityReadGate", "activity.readGate"],
   ["activityDeploymentId", "activity.deploymentId"],
   ["credentialEncryptionKey", "credentials.encryptionKey"],
-  ["credentialHealth", "credentials.health"],
   ["toolCacheTtlSeconds", "discovery.catalogTtlSeconds"],
   ["persistToolCatalog", "discovery.persistCatalog"],
   ["toolCatalogStaleSeconds", "discovery.staleCatalogSeconds"],
@@ -332,6 +251,23 @@ const hasOwn = (value: object, key: PropertyKey): boolean =>
  */
 function assertNoLegacyConfig(config: ConnectaConfig): void {
   const candidate = config as unknown as Record<PropertyKey, unknown>;
+  if (hasOwn(candidate, "toolkits")) {
+    throw new Error(
+      "ConnectaConfig.toolkits was removed in issue #178. Deploy one " +
+        "connecta instance per audience instead; see ethos.md.",
+    );
+  }
+  const credentials = candidate.credentials;
+  const hasNestedHealth =
+    typeof credentials === "object" &&
+    credentials !== null &&
+    hasOwn(credentials, "health");
+  if (hasOwn(candidate, "credentialHealth") || hasNestedHealth) {
+    throw new Error(
+      "`credentials.health` and legacy `credentialHealth` were removed in " +
+        "issue #179. Credentials now fail at use; see ethos.md.",
+    );
+  }
   const found: Array<readonly [string, string]> = [];
   if (hasOwn(candidate, "activity")) {
     const activity = candidate.activity;
@@ -371,7 +307,6 @@ function assertNoLegacyConfig(config: ConnectaConfig): void {
 function warnInsecureConfig(
   config: ConnectaConfig,
   inboundAuth: InboundAuth[],
-  toolkits: ReadonlyMap<string, Toolkit> | undefined,
   logger: Logger,
 ): void {
   const oauthConnectors = config.connectors.filter((c) => c.finishAuth);
@@ -402,64 +337,6 @@ function warnInsecureConfig(
     );
   }
 
-  // Toolkits that nothing binds to an identity: selection is then self-service,
-  // and the boundary organizes the surface rather than protecting it. Three
-  // distinct shapes, so three distinct warnings — an operator can only act on
-  // the one they are actually in.
-  //
-  // All are keyed off the RESOLVED toolkits, which is the same map `?toolkit=`
-  // resolves against, rather than the presence of the config key: `toolkits: {}`
-  // is a truthy object that resolves to nothing selectable, so warning about a
-  // choice no caller can make would name a risk that does not exist.
-  if (toolkits) {
-    const unbound = inboundAuth.filter((provider) => !provider.toolkitBinding);
-    if (inboundAuth.length === 0) {
-      // No auth at all ⇒ no identity exists to bind, so binding is not even the
-      // fix here. The open-mode warning above covers the wider exposure.
-      logger.warn(
-        "[connecta] toolkits are configured but there is no inbound " +
-          "authentication: with no identity to bind a toolkit to, any caller " +
-          "can choose any toolkit or omit ?toolkit= and see every connector. " +
-          "Configure `auth` (for example bearerToken(...) or Clerk), then bind " +
-          "each credential with `toolkits: [...]`.",
-      );
-    } else if (unbound.length === inboundAuth.length) {
-      // Authenticated, but every credential may still select every view. This is
-      // the shape issue #37 exists to close, and it is invisible without a line
-      // saying so: nothing fails, the teams are simply not separated.
-      logger.warn(
-        "[connecta] toolkits are configured but no inbound identity is bound " +
-          "to one: every credential `auth` admits can select any toolkit, or " +
-          "omit ?toolkit= and see the whole deployment, so a token handed to " +
-          "one team also opens the others' views. Bind each credential with " +
-          "`toolkits: [...]` on its auth adapter (add `unscoped: true` for an " +
-          "operator credential that should still see everything).",
-      );
-    } else if (unbound.length > 0) {
-      // The dangerous middle: SOME credentials are bound, which is exactly when
-      // an operator believes the deployment is separated — while one forgotten
-      // provider still opens every view and the whole deployment-wide surface.
-      // Naming the unbound providers is the point; an intentionally unrestricted
-      // credential says so with `unscoped: true` and stops appearing here.
-      const counted = new Map<string, number>();
-      for (const provider of unbound) {
-        counted.set(provider.kind, (counted.get(provider.kind) ?? 0) + 1);
-      }
-      const named = [...counted]
-        .map(([kind, count]) => (count > 1 ? `${kind} x${count}` : kind))
-        .join(", ");
-      logger.warn(
-        `[connecta] toolkits are bound on some inbound auth providers but not ` +
-          `all: ${named} ${unbound.length === 1 ? "declares" : "declare"} no ` +
-          "binding, so a caller that provider admits can still select any " +
-          "toolkit, connect unscoped, and read the deployment-wide operator " +
-          "surfaces — whatever the bound credentials beside it allow. Bind it " +
-          "too, or declare the exemption with `toolkits: [...], unscoped: true` " +
-          "if it is meant to be an operator credential.",
-      );
-    }
-  }
-
   // Branding URLs that failed their scheme gate. Rendering silently falls back
   // (a bad URL must not take the page down), so this warning is the only way an
   // operator learns their value never reached the page.
@@ -536,8 +413,10 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const credentialConnectors = config.connectors.filter((c) => c.credential);
   const encryptionKey = config.credentials?.encryptionKey;
   if (credentialConnectors.length > 0 && !encryptionKey) {
-    throw new Error(
-      `credentials.encryptionKey is required by connector credentials: ${credentialConnectors.map((c) => c.id).join(", ")}`,
+    logger.warn(
+      "Operator-managed credentials are unavailable because " +
+        "credentials.encryptionKey is not configured for connectors: " +
+        credentialConnectors.map((c) => c.id).join(", "),
     );
   }
   const credentialVault = encryptionKey
@@ -546,25 +425,25 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const registry = new Registry(config.connectors, {
     storage,
     logger,
-    credentialVault,
-    toolCacheTtlSeconds: config.discovery?.catalogTtlSeconds,
-    persistToolCatalog: config.discovery?.persistCatalog,
-    toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
-    maxResultBytes: config.calls?.maxResultBytes,
-    maxBatchResultBytes: config.calls?.maxBatchResultBytes,
-    credentialHealth: config.credentials?.health,
+    ...(credentialVault !== undefined ? { credentialVault } : {}),
+    ...(config.discovery?.catalogTtlSeconds !== undefined
+      ? { toolCacheTtlSeconds: config.discovery.catalogTtlSeconds }
+      : {}),
+    ...(config.discovery?.persistCatalog !== undefined
+      ? { persistToolCatalog: config.discovery.persistCatalog }
+      : {}),
+    ...(config.discovery?.staleCatalogSeconds !== undefined
+      ? { toolCatalogStaleSeconds: config.discovery.staleCatalogSeconds }
+      : {}),
+    ...(config.calls?.maxResultBytes !== undefined
+      ? { maxResultBytes: config.calls.maxResultBytes }
+      : {}),
+    ...(config.calls?.maxBatchResultBytes !== undefined
+      ? { maxBatchResultBytes: config.calls.maxBatchResultBytes }
+      : {}),
   });
-  // Throws on every structural mistake it can see (see resolveToolkits): a
-  // typo must not become a scope the operator never wrote. Note this is about
-  // the scope being *intended*, not about it being an access check — a toolkit
-  // scopes visibility, and `auth` remains the thing deciding who gets in.
-  const toolkits = resolveToolkits(config.toolkits, config.connectors);
   const inboundAuth = normalizeAuth(config.auth);
-  // Same contract for the identity half: a binding that names a toolkit this
-  // deployment does not declare would deny that credential every connection,
-  // with a 403 its client reports as a transport failure. Throw here instead.
-  validateToolkitBindings(inboundAuth, toolkits);
-  warnInsecureConfig(config, inboundAuth, toolkits, logger);
+  warnInsecureConfig(config, inboundAuth, logger);
   const requestAdmission = admissionController(
     config.admission?.requests,
     REQUEST_ADMISSION_DEFAULTS,
@@ -588,24 +467,38 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const handler = createFetchHandler({
     registry,
     auth: inboundAuth,
-    publicUrl: config.publicUrl,
+    ...(config.publicUrl !== undefined ? { publicUrl: config.publicUrl } : {}),
     serverInfo: {
       ...config.serverInfo,
       name: config.serverInfo?.name ?? "connecta",
       version: config.serverInfo?.version ?? CONNECTA_VERSION,
     },
     logger,
-    activity: config.activity?.store,
-    activityReadGate: config.activity?.readGate,
-    activityDeploymentId: config.activity?.deploymentId,
-    executor,
+    ...(config.activity?.store !== undefined
+      ? { activity: config.activity.store }
+      : {}),
+    ...(config.activity?.readGate !== undefined
+      ? { activityReadGate: config.activity.readGate }
+      : {}),
+    ...(config.activity?.deploymentId !== undefined
+      ? { activityDeploymentId: config.activity.deploymentId }
+      : {}),
+    ...(executor !== undefined ? { executor } : {}),
     requestAdmission,
-    defaultToolTimeoutMs: config.calls?.defaultTimeoutMs,
-    probeTimeoutMs: config.discovery?.probeTimeoutMs,
-    credentialVault,
-    deploymentInfo: config.deploymentInfo,
-    branding: config.branding,
-    ...(toolkits ? { toolkits } : {}),
+    ...(config.calls?.defaultTimeoutMs !== undefined
+      ? { defaultToolTimeoutMs: config.calls.defaultTimeoutMs }
+      : {}),
+    ...(config.discovery?.probeTimeoutMs !== undefined
+      ? { probeTimeoutMs: config.discovery.probeTimeoutMs }
+      : {}),
+    ...(config.discovery?.concurrency !== undefined
+      ? { discoveryConcurrency: config.discovery.concurrency }
+      : {}),
+    ...(credentialVault !== undefined ? { credentialVault } : {}),
+    ...(config.deploymentInfo !== undefined
+      ? { deploymentInfo: config.deploymentInfo }
+      : {}),
+    ...(config.branding !== undefined ? { branding: config.branding } : {}),
   });
   let closePromise: Promise<void> | undefined;
   return {
@@ -617,33 +510,6 @@ export function createConnecta(config: ConnectaConfig): Connecta {
           : undefined,
       ),
     registry,
-    checkCredentials: (opts = {}) => {
-      // A scheduled check has no inbound request to derive an origin from, and
-      // a connector context without one would mint OAuth redirect URIs against
-      // a guess. Say so instead: the fix is one config line.
-      const baseUrl = opts.baseUrl ?? config.publicUrl;
-      if (!baseUrl) {
-        // Rejected, not thrown: the callers this is written for are
-        // `ctx.waitUntil(...)` and `.catch(...)` on the returned promise, and a
-        // synchronous throw escapes both — it would take down a scheduled
-        // handler instead of being reported by it.
-        return Promise.reject(
-          new Error(
-            "checkCredentials() needs a base URL: set `publicUrl` on the " +
-              "config (recommended — it is also what downstream OAuth " +
-              "callbacks use) or pass checkCredentials({ baseUrl }).",
-          ),
-        );
-      }
-      return registry.checkCredentialHealth(
-        baseUrl,
-        {
-          ...(opts.force !== undefined ? { force: opts.force } : {}),
-          ...(opts.ids ? { ids: opts.ids } : {}),
-        },
-        opts.defer,
-      );
-    },
     close: async () => {
       closePromise ??= Promise.resolve().then(async () => {
         requestAdmission.close();
@@ -673,23 +539,6 @@ export { CONNECTA_VERSION } from "./version.js";
 // the class itself, the credential vault, and the meta-tool/sandbox factories
 // are internal factoring and are deliberately not part of the API surface.
 export type { Registry } from "./registry.js";
-// Config-as-code shapes for `ConnectaConfig.toolkits` and the identity bindings
-// that gate them. The resolved `Toolkit` and the `ScopedRegistry` that enforces
-// it are internal factoring.
-export type {
-  ToolkitBindingOptions,
-  ToolkitConfig,
-  ToolkitDefinition,
-} from "./toolkits.js";
-// Credential health: the config shape, and the result shape a scheduled
-// `checkCredentials()` returns. The checker itself is internal factoring.
-export type {
-  CredentialCheckResult,
-  CredentialCheckSkip,
-  CredentialCheckState,
-  CredentialHealthConfig,
-  CredentialHealthRecord,
-} from "./credential-health.js";
 
 export type {
   RemoteMcpOptions,
@@ -718,7 +567,6 @@ export type {
   ExecutorLease,
   ExecutorProvider,
   InboundAuth,
-  ToolkitBinding,
   UiAuthConfig,
   AuthResult,
   JsonSchema,