@fungi.computer/veil 0.4.0 → 0.5.0

package/dist/connections/update.js

@@ -0,0 +1,81 @@
+import * as Effect from "effect/Effect";
+import { ConnectionsError, updateInputSchema, } from "./contract.js";
+import { decode, io, sync } from "./internal.js";
+import { decodeTable } from "./openapi.js";
+/** Owner edits guarded by the version the owner last saw; replays are idempotent. */
+export function createUpdate(deps) {
+    const { store } = deps;
+    return (actor, raw) => Effect.gen(function* () {
+        const input = yield* sync(() => {
+            store.authorize(actor);
+            const parsed = decode(updateInputSchema, raw);
+            if (parsed.credential?.kind === "oauth" ||
+                (parsed.credential?.kind === "static") !==
+                    (parsed.secret !== undefined))
+                throw new ConnectionsError(parsed.credential === undefined ? "invalid_input" : "unsupported");
+            return parsed;
+        });
+        const stamp = JSON.stringify([
+            "update",
+            input.connectionId,
+            input.expectedVersion,
+            input.name ?? null,
+            input.label ?? null,
+            input.baseUrl ?? null,
+            input.table === undefined ? null : JSON.stringify(input.table),
+            input.credential ?? null,
+            input.secret !== undefined,
+        ]);
+        const replay = yield* sync(() => {
+            const receipt = store.receipt(input.requestId);
+            if (receipt !== null && receipt.stamp !== stamp)
+                throw new ConnectionsError("conflict");
+            return receipt;
+        });
+        if (replay !== null)
+            return { connectionId: replay.connectionId, version: replay.version };
+        const row = yield* sync(() => {
+            const found = store.connection(input.connectionId);
+            if (found.version !== input.expectedVersion)
+                throw new ConnectionsError("conflict");
+            if (found.state === "revoked" || found.state === "pending")
+                throw new ConnectionsError(found.state === "revoked" ? "revoked" : "pending");
+            if ((input.table !== undefined || input.baseUrl !== undefined) &&
+                found.surface.kind !== "openapi")
+                throw new ConnectionsError("invalid_input");
+            // A new destination must not inherit a credential sealed for the old one.
+            if (input.baseUrl !== undefined &&
+                input.credential === undefined &&
+                found.credential.kind !== "none" &&
+                new URL(input.baseUrl).href !== found.surface.url)
+                throw new ConnectionsError("invalid_input");
+            if (input.name !== undefined)
+                store.checkName(input.name, found.id);
+            return found;
+        });
+        const baseUrl = yield* sync(() => input.baseUrl === undefined
+            ? row.surface.url
+            : store.publicUrl(input.baseUrl));
+        const next = input.table === undefined
+            ? null
+            : yield* io(() => decodeTable(input.table));
+        const credential = input.credential ?? row.credential;
+        const locator = input.secret === undefined
+            ? row.locator
+            : yield* deps.custody.put({ ownerId: deps.ownerId, connectionId: row.id, credential }, input.secret);
+        return yield* sync(() => store.commit({
+            actor,
+            update: input,
+            stamp,
+            row,
+            baseUrl,
+            table: next?.operations ?? row.surface.table,
+            digest: next?.digest ?? row.surface.digest ?? null,
+            credential,
+            locator,
+        })).pipe(Effect.tapError(() => sync(() => {
+            if (input.secret !== undefined && locator !== null)
+                store.discard(row.id, locator, credential);
+        })));
+    });
+}

package/dist/gatekeeper.d.ts

@@ -1,6 +1,7 @@
-import { type OpenApiCredentialStore, type OpenApiOAuthProvider, type OpenApiDoorOptions } from "./openapi.js";
+import { type OpenApiCredentialKeyring, type OpenApiCredentialStore, type OpenApiOAuthProvider, type OpenApiDoorOptions } from "./openapi.js";
 import { type OpenApiEffects } from "./openapi-effect.js";
 import type { PublicConnect } from "./public-fetch.js";
+import { type ConnectionsCustodian } from "./connections/nango.js";
 import { type WorldSeatCustodian } from "./world-seat.js";
 import type { ModelKeyCustodian } from "./model-keys.js";
 import { createModelKeyEgress, type ModelKeyGrants } from "./model-key-grants.js";
@@ -21,6 +22,7 @@ import * as Schema from "effect/Schema";
  */
 export { providerFetch };
 export type { ProviderEgress, ProviderRoute };
+export type { ConnectionsCustodian };
 /** Private Worker bindings, never Team storage or public response fields. */
 export type VeilBindings = ProviderKeyBindings & Readonly<{
     WEBHOOK_TRIGGER_MASTER_KEY?: string;
@@ -32,6 +34,10 @@ export type VeilBindings = ProviderKeyBindings & Readonly<{
     NANGO_WEBHOOK_SIGNING_KEY?: string;
     NANGO_GITHUB_INTEGRATION_ID?: string;
     NANGO_GITHUB_GIT_INTEGRATION_ID?: string;
+    /** API-key integration that holds pasted credentials for Team connections. */
+    NANGO_CONNECTIONS_INTEGRATION_ID?: string;
+    /** Comma-separated Nango integrations an owner may sign in through for connections. */
+    NANGO_CONNECTIONS_OAUTH_INTEGRATIONS?: string;
     /** Public Connect UI base that Nango's issued links must stay under. */
     NANGO_CONNECT_BASE_URL?: string;
     /** Public Nango API origin the Connect UI in the browser must call. */
@@ -51,6 +57,13 @@ export type VeilBindings = ProviderKeyBindings & Readonly<{
      */
     HUB_LOCAL_MODE?: string;
 }>;
+/**
+ * Optional Nango custody for Team connections. A Hub with none of the Nango
+ * bindings keeps sealed custody and still connects OAuth MCP and OpenAPI.
+ */
+export declare function configuredConnectionsCustody(env: VeilBindings): ConnectionsCustodian | undefined;
+/** The Nango integrations an owner may sign in through for connections. */
+export declare function configuredConnectionsOAuthIntegrations(env: VeilBindings): readonly string[];
 export declare function configuredGitHubState(env: VeilBindings): {
     github: "off";
     metadataIntegrationId?: never;
@@ -176,13 +189,18 @@ export declare function configuredComputerGitCustodian(env: VeilBindings): {
 /** The decoded key selects one of the two configured profiles only. The
  * selected maintained custodian still verifies the original signed body. */
 export declare function verifyVeilWebhook(env: VeilBindings, rawBody: string, signature: string): Promise<{
+    profile: "connections";
+    ownerId: string;
+} | {
     operation: "creation" | "refresh_failed";
     completion: import("./index.js").VerifiedCompletion;
     profile: "computer-git";
+    ownerId?: never;
 } | {
     operation: "creation" | "refresh_failed";
     completion: import("./index.js").VerifiedCompletion;
     profile: "agent-metadata";
+    ownerId?: never;
 }>;
 export type OpenApiHostOptions = Readonly<{
     connect: PublicConnect;
@@ -192,6 +210,8 @@ export type OpenApiHostOptions = Readonly<{
     previousCredentialKeys?: Readonly<Record<string, string>>;
     oauthProviders?: Readonly<Record<string, OpenApiOAuthProvider>>;
 }>;
+/** The keyring that seals OpenAPI credentials; only Gatekeeper reads the master key. */
+export declare function openApiCredentialKeyring(env: VeilBindings, previous?: Readonly<Record<string, string>>): OpenApiCredentialKeyring | undefined;
 /** Anonymous calls need no secret; API-key/bearer calls require configured Veil custody. */
 export declare function configuredOpenApiDoor(env: VeilBindings, options: OpenApiHostOptions): Readonly<{
     seal: (access: import("./openapi-contract.js").OpenApiAccess, credential: string, signal: AbortSignal) => Promise<void>;

package/dist/gatekeeper.js

@@ -2,6 +2,8 @@ import { createOpenApiDoor, } from "./openapi.js";
 import { createOpenApiEffects } from "./openapi-effect.js";
 import { createDnsOverHttpsResolver } from "./model-key-network.js";
 import { createNangoCustodian } from "./nango.js";
+import { ConnectionsError } from "./connections/contract.js";
+import { createNangoCustody, } from "./connections/nango.js";
 import { createWebhookTriggerSecrets } from "./webhook-trigger-secrets.js";
 import { createNangoGitCustodian } from "./nango-git.js";
 import { createNangoModelKeyCustodian } from "./nango-model-keys.js";
@@ -26,6 +28,39 @@ import * as Exit from "effect/Exit";
  * Hub code reaches a provider only through `configuredProviderEgress`.
  */
 export { providerFetch };
+/**
+ * Optional Nango custody for Team connections. A Hub with none of the Nango
+ * bindings keeps sealed custody and still connects OAuth MCP and OpenAPI.
+ */
+export function configuredConnectionsCustody(env) {
+    if (!env.NANGO_SERVER_URL ||
+        !env.NANGO_API_KEY ||
+        !env.NANGO_WEBHOOK_SIGNING_KEY ||
+        !env.NANGO_CONNECT_BASE_URL ||
+        !env.NANGO_PUBLIC_API_URL ||
+        !env.NANGO_CONNECTIONS_INTEGRATION_ID)
+        return undefined;
+    try {
+        return createNangoCustody({
+            serverUrl: env.NANGO_SERVER_URL,
+            apiKey: env.NANGO_API_KEY,
+            webhookSigningKey: env.NANGO_WEBHOOK_SIGNING_KEY,
+            staticIntegrationId: env.NANGO_CONNECTIONS_INTEGRATION_ID,
+            connectBaseUrl: env.NANGO_CONNECT_BASE_URL,
+            publicApiUrl: env.NANGO_PUBLIC_API_URL,
+        });
+    }
+    catch {
+        throw new VeilError("unavailable");
+    }
+}
+/** The Nango integrations an owner may sign in through for connections. */
+export function configuredConnectionsOAuthIntegrations(env) {
+    return (env.NANGO_CONNECTIONS_OAUTH_INTEGRATIONS ?? "")
+        .split(",")
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0);
+}
 export function configuredGitHubState(env) {
     const metadataIntegrationId = env.NANGO_GITHUB_INTEGRATION_ID;
     const gitIntegrationId = env.NANGO_GITHUB_GIT_INTEGRATION_ID;
@@ -156,13 +191,22 @@ export function configuredComputerGitCustodian(env) {
  * selected maintained custodian still verifies the original signed body. */
 export async function verifyVeilWebhook(env, rawBody, signature) {
     const state = configuredGitHubState(env);
-    if (state.github === "off")
+    const connectionIntegrations = configuredConnectionsOAuthIntegrations(env);
+    if (state.github === "off" && connectionIntegrations.length === 0)
         throw new VeilError("github_not_configured");
     const decoded = Schema.decodeUnknownExit(Schema.fromJsonString(Schema.Struct({
         providerConfigKey: Schema.NonEmptyString,
     })))(rawBody);
     if (Exit.isFailure(decoded))
         throw new VeilError("invalid_completion");
+    // A connection's sign-in runs through an integration the operator listed for it.
+    if (connectionIntegrations.includes(decoded.value.providerConfigKey))
+        return {
+            profile: "connections",
+            ownerId: await verifiedConnectionOwner(env, rawBody, signature),
+        };
+    if (state.github === "off")
+        throw new VeilError("github_not_configured");
     if (decoded.value.providerConfigKey === state.gitIntegrationId) {
         return {
             profile: "computer-git",
@@ -177,6 +221,24 @@ export async function verifyVeilWebhook(env, rawBody, signature) {
     }
     throw new VeilError("invalid_completion");
 }
+/** The signed sign-in names the Team that began it; only a verified body is believed. */
+async function verifiedConnectionOwner(env, rawBody, signature) {
+    const custody = configuredConnectionsCustody(env);
+    if (custody === undefined)
+        throw new VeilError("unavailable");
+    try {
+        return (await custody.verifyCompletion(rawBody, signature)).ownerId;
+    }
+    catch (cause) {
+        if (cause instanceof ConnectionsError)
+            throw new VeilError(cause.code === "unsupported"
+                ? "unsupported"
+                : cause.code === "unavailable"
+                    ? "unavailable"
+                    : "invalid_completion", { cause });
+        throw cause;
+    }
+}
 function configuredCustodian(env, integrationId) {
     if (!env.NANGO_SERVER_URL ||
         !env.NANGO_API_KEY ||
@@ -199,6 +261,14 @@ function configuredCustodian(env, integrationId) {
         throw new VeilError("unavailable");
     }
 }
+/** The keyring that seals OpenAPI credentials; only Gatekeeper reads the master key. */
+export function openApiCredentialKeyring(env, previous) {
+    const key = env.OPENAPI_CREDENTIAL_MASTER_KEY;
+    if (!key)
+        return undefined;
+    const id = env.OPENAPI_CREDENTIAL_KEY_ID ?? "primary";
+    return { activeKeyId: id, keys: { ...previous, [id]: key } };
+}
 /** Gatekeeper owns the common opaque configuration for both runtime facades. */
 function openApiHostConfiguration(env, options) {
     const doorOptions = {
@@ -208,17 +278,9 @@ function openApiHostConfiguration(env, options) {
     };
     if (options.oauthProviders)
         doorOptions.oauthProviders = options.oauthProviders;
-    if (env.OPENAPI_CREDENTIAL_MASTER_KEY)
-        doorOptions.custody = {
-            keys: {
-                activeKeyId: env.OPENAPI_CREDENTIAL_KEY_ID ?? "primary",
-                keys: {
-                    ...options.previousCredentialKeys,
-                    [env.OPENAPI_CREDENTIAL_KEY_ID ?? "primary"]: env.OPENAPI_CREDENTIAL_MASTER_KEY,
-                },
-            },
-            store: options.store,
-        };
+    const keys = openApiCredentialKeyring(env, options.previousCredentialKeys);
+    if (keys)
+        doorOptions.custody = { keys, store: options.store };
     return doorOptions;
 }
 /** Anonymous calls need no secret; API-key/bearer calls require configured Veil custody. */

package/dist/nango.d.ts

@@ -1,4 +1,38 @@
+import * as Schema from "effect/Schema";
 import { type CredentialCustodian } from "./index.js";
+export declare const tagsSchema: Schema.Struct<{
+    readonly veil_team_id: Schema.NonEmptyString;
+    readonly veil_attempt_id: Schema.NonEmptyString;
+    readonly veil_principal_id: Schema.NonEmptyString;
+}>;
+export declare const sessionSchema: Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly token: Schema.NonEmptyString;
+        readonly connect_link: Schema.NonEmptyString;
+        readonly expires_at: Schema.DateFromString;
+    }>;
+}>;
+export declare const webhookEnvelopeSchema: Schema.Struct<{
+    readonly type: Schema.NonEmptyString;
+    readonly operation: Schema.optional<Schema.NonEmptyString>;
+}>;
+/** Nango auth webhook fields shared by creation and refresh notifications. */
+export declare const authWebhookSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"auth">;
+    readonly operation: Schema.Literals<readonly ["creation", "refresh"]>;
+    readonly success: Schema.Boolean;
+    readonly connectionId: Schema.NonEmptyString;
+    readonly providerConfigKey: Schema.NonEmptyString;
+    readonly tags: Schema.Struct<{
+        readonly veil_team_id: Schema.NonEmptyString;
+        readonly veil_attempt_id: Schema.NonEmptyString;
+        readonly veil_principal_id: Schema.NonEmptyString;
+    }>;
+    readonly endUser: Schema.Struct<{
+        readonly endUserId: Schema.NonEmptyString;
+        readonly organizationId: Schema.NonEmptyString;
+    }>;
+}>;
 /** Trusted host configuration; never supplied by a model or Connect browser.
  * The public Connect document and API URLs are independent of the internal
  * serverUrl the Hub uses for custody. */
@@ -12,5 +46,12 @@ export type NangoCustodianOptions = Readonly<{
     /** Deadline for one custodian request and its body; a miss is `unavailable`. */
     requestTimeoutMs?: number;
 }>;
+export declare function publicUrl(value: string): URL;
+/** The Connect document handed to browsers: Nango's issued link, confined to
+ * the configured Connect UI and pinned to the configured public API. */
+export declare function connectDocument(session: Readonly<{
+    token: string;
+    connectUrl: string;
+}>, base: URL, api: URL): string;
 /** Pinned Nango Connect/connection REST contract and maintained raw-body verifier. */
 export declare function createNangoCustodian(options: NangoCustodianOptions): CredentialCustodian;

package/dist/nango.js

@@ -2,24 +2,24 @@ import * as Schema from "effect/Schema";
 import * as Exit from "effect/Exit";
 import { VeilError, } from "./index.js";
 const text = Schema.NonEmptyString;
-const tagsSchema = Schema.Struct({
+export const tagsSchema = Schema.Struct({
     veil_team_id: text,
     veil_attempt_id: text,
     veil_principal_id: text,
 });
-const sessionSchema = Schema.Struct({
+export const sessionSchema = Schema.Struct({
     data: Schema.Struct({
         token: text,
         connect_link: text,
         expires_at: Schema.DateFromString,
     }),
 });
-const webhookEnvelopeSchema = Schema.Struct({
+export const webhookEnvelopeSchema = Schema.Struct({
     type: text,
     operation: Schema.optional(text),
 });
 /** Nango auth webhook fields shared by creation and refresh notifications. */
-const authWebhookSchema = Schema.Struct({
+export const authWebhookSchema = Schema.Struct({
     type: Schema.Literal("auth"),
     operation: Schema.Literals(["creation", "refresh"]),
     success: Schema.Boolean,
@@ -52,7 +52,7 @@ const absentSchema = Schema.Struct({
 });
 /** A custodian that stops answering is an outage, retried later, never a dead credential. */
 const defaultRequestTimeoutMs = 10_000;
-function publicUrl(value) {
+export function publicUrl(value) {
     let url;
     try {
         url = new URL(value);
@@ -70,7 +70,7 @@ function publicUrl(value) {
 }
 /** The Connect document handed to browsers: Nango's issued link, confined to
  * the configured Connect UI and pinned to the configured public API. */
-function connectDocument(session, base, api) {
+export function connectDocument(session, base, api) {
     let document;
     try {
         document = new URL(session.connectUrl);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/veil",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Team-authorized credential custody and provider access",
   "type": "module",
@@ -86,6 +86,14 @@
     "./connections": {
       "types": "./dist/connections/index.d.ts",
       "import": "./dist/connections/index.js"
+    },
+    "./connections/nango": {
+      "types": "./dist/connections/nango.d.ts",
+      "import": "./dist/connections/nango.js"
+    },
+    "./connections/source": {
+      "types": "./dist/connections/source.d.ts",
+      "import": "./dist/connections/source.js"
     }
   },
   "files": [
@@ -96,6 +104,7 @@
   "dependencies": {
     "@fungi.computer/cairn": "0.1.0",
     "@fungi.computer/forage": "0.3.1",
+    "@fungi.computer/mycelium": "0.3.4",
     "@modelcontextprotocol/client": "2.0.0",
     "@nangohq/node": "0.71.6",
     "effect": "4.0.2",
@@ -105,6 +114,7 @@
   },
   "devDependencies": {
     "@fungi.computer/watchdog": "0.1.0",
+    "@modelcontextprotocol/server": "2.0.0",
     "@types/node": "24.13.3",
     "typescript": "5.9.3",
     "vitest": "4.1.11"