@fungi.computer/veil 0.5.0 → 0.6.0

package/dist/nango.js

@@ -1,6 +1,5 @@
 import * as Schema from "effect/Schema";
-import * as Exit from "effect/Exit";
-import { VeilError, } from "./index.js";
+import { VeilError } from "./index.js";
 const text = Schema.NonEmptyString;
 export const tagsSchema = Schema.Struct({
     veil_team_id: text,
@@ -28,30 +27,6 @@ export const authWebhookSchema = Schema.Struct({
     tags: tagsSchema,
     endUser: Schema.Struct({ endUserId: text, organizationId: text }),
 });
-/** GitHub's own unauthorized body, as relayed verbatim by the Nango proxy.
- * Nango's own errors use an `error` envelope and remain unavailable. */
-const providerUnauthorizedSchema = Schema.Struct({
-    message: text,
-    documentation_url: text,
-});
-const connectionSchema = Schema.Struct({
-    connection_id: text,
-    provider_config_key: text,
-    tags: tagsSchema,
-    end_user: Schema.Struct({
-        id: text,
-        organization: Schema.Struct({ id: text }),
-    }),
-});
-const connectionsSchema = Schema.Struct({
-    connections: Schema.Array(connectionSchema),
-});
-const deletedSchema = Schema.Struct({ success: Schema.Literal(true) });
-const absentSchema = Schema.Struct({
-    error: Schema.Struct({ code: Schema.Literal("unknown_connection") }),
-});
-/** A custodian that stops answering is an outage, retried later, never a dead credential. */
-const defaultRequestTimeoutMs = 10_000;
 export function publicUrl(value) {
     let url;
     try {
@@ -88,213 +63,3 @@ export function connectDocument(session, base, api) {
     document.searchParams.set("apiURL", api.href);
     return document.href;
 }
-/** Pinned Nango Connect/connection REST contract and maintained raw-body verifier. */
-export function createNangoCustodian(options) {
-    let server;
-    try {
-        server = new URL(options.serverUrl);
-    }
-    catch {
-        throw new VeilError("invalid_input");
-    }
-    if (!options.apiKey ||
-        !options.webhookSigningKey ||
-        !options.integrationId ||
-        server.username ||
-        server.password ||
-        server.search ||
-        server.hash ||
-        server.pathname !== "/" ||
-        (server.protocol !== "https:" && server.protocol !== "http:"))
-        throw new VeilError("invalid_input");
-    const connectBase = publicUrl(options.connectBaseUrl);
-    if (!connectBase.pathname.endsWith("/"))
-        connectBase.pathname += "/";
-    const publicApi = publicUrl(options.publicApiUrl);
-    const decode = (schema, raw, code = "invalid_response") => {
-        try {
-            return Schema.decodeUnknownSync(Schema.fromJsonString(schema))(raw);
-        }
-        catch {
-            throw new VeilError(code);
-        }
-    };
-    const requestTimeoutMs = options.requestTimeoutMs ?? defaultRequestTimeoutMs;
-    const request = async (path, signal, init = {}) => {
-        try {
-            signal.throwIfAborted();
-            const headers = new Headers(init.headers);
-            headers.set("Authorization", `Bearer ${options.apiKey}`);
-            // The deadline also aborts the body stream that `body` reads next.
-            return await fetch(new URL(path, server), {
-                ...init,
-                headers,
-                signal: AbortSignal.any([
-                    signal,
-                    AbortSignal.timeout(requestTimeoutMs),
-                ]),
-                redirect: "manual",
-            });
-        }
-        catch {
-            throw new VeilError(signal.aborted ? "cancelled" : "unavailable");
-        }
-    };
-    const body = async (response, signal) => {
-        try {
-            return await response.text();
-        }
-        catch {
-            throw new VeilError(signal.aborted ? "cancelled" : "unavailable");
-        }
-    };
-    const requireSuccess = (response) => {
-        if (!response.ok)
-            throw new VeilError("unavailable");
-    };
-    const tags = (teamId, attemptId, principalId) => ({
-        veil_team_id: teamId,
-        veil_attempt_id: attemptId,
-        veil_principal_id: principalId,
-    });
-    const completion = (row, integrationId, locator) => ({
-        teamId: row.veil_team_id,
-        attemptId: row.veil_attempt_id,
-        principalId: row.veil_principal_id,
-        integrationId,
-        locator,
-    });
-    /**
-     * Maintained HMAC over the raw body first; only then decode the operation.
-     * The Nango SDK (and its HTTP client) loads with the first webhook rather
-     * than with every Worker that hosts a custodian.
-     */
-    const verifyWebhook = (rawBody, signature) => import("@nangohq/node").then(({ Nango }) => {
-        const verifier = new Nango({
-            host: server.origin,
-            apiKey: options.apiKey,
-            webhookSigningKey: options.webhookSigningKey,
-        });
-        if (!verifier.verifyIncomingWebhookRequest(rawBody, {
-            "X-Nango-Hmac-Sha256": signature,
-        }))
-            throw new VeilError("invalid_completion");
-        const envelope = decode(webhookEnvelopeSchema, rawBody, "invalid_completion");
-        if (envelope.type !== "auth" ||
-            (envelope.operation !== "creation" && envelope.operation !== "refresh"))
-            throw new VeilError("unsupported");
-        const row = decode(authWebhookSchema, rawBody, "invalid_completion");
-        // Handled: a successful creation, or a failed credential refresh.
-        if (row.success !== (row.operation === "creation"))
-            throw new VeilError("unsupported");
-        if (row.providerConfigKey !== options.integrationId ||
-            row.endUser.endUserId !== row.tags.veil_principal_id ||
-            row.endUser.organizationId !== row.tags.veil_team_id)
-            throw new VeilError("invalid_completion");
-        return {
-            operation: row.operation === "creation" ? "creation" : "refresh_failed",
-            completion: completion(row.tags, row.providerConfigKey, row.connectionId),
-        };
-    });
-    return {
-        async openSession(input, signal) {
-            if (input.integrationId !== options.integrationId)
-                throw new VeilError("denied");
-            const response = await request("/connect/sessions", signal, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    allowed_integrations: [options.integrationId],
-                    end_user: { id: input.principalId },
-                    organization: { id: input.teamId },
-                    tags: tags(input.teamId, input.attemptId, input.principalId),
-                }),
-            });
-            requireSuccess(response);
-            const { data } = decode(sessionSchema, await body(response, signal));
-            return {
-                token: data.token,
-                connectUrl: connectDocument({ token: data.token, connectUrl: data.connect_link }, connectBase, publicApi),
-                expiresAt: data.expires_at.getTime(),
-            };
-        },
-        verifyWebhook,
-        async verifyCompletion(rawBody, signature) {
-            const event = await verifyWebhook(rawBody, signature);
-            if (event.operation !== "creation")
-                throw new VeilError("unsupported");
-            return event.completion;
-        },
-        async findCompletion(attempt, signal) {
-            if (attempt.integrationId !== options.integrationId)
-                throw new VeilError("denied");
-            const expected = tags(attempt.teamId, attempt.attemptId, attempt.actorUserId);
-            const query = new URLSearchParams({
-                integrationId: options.integrationId,
-                endUserId: attempt.actorUserId,
-                endUserOrganizationId: attempt.teamId,
-                limit: "2",
-                page: "0",
-            });
-            for (const [key, value] of Object.entries(expected))
-                query.set(`tags[${key}]`, value);
-            const response = await request(`/connections?${query.toString()}`, signal);
-            requireSuccess(response);
-            const { connections } = decode(connectionsSchema, await body(response, signal));
-            // Selected server filters before LIMIT; two rows are sufficient to prove ambiguity.
-            for (const row of connections) {
-                if (row.provider_config_key !== options.integrationId ||
-                    row.end_user.id !== attempt.actorUserId ||
-                    row.end_user.organization.id !== attempt.teamId ||
-                    row.tags.veil_team_id !== attempt.teamId ||
-                    row.tags.veil_attempt_id !== attempt.attemptId ||
-                    row.tags.veil_principal_id !== attempt.actorUserId)
-                    throw new VeilError("invalid_response");
-            }
-            if (connections.length === 0)
-                return { status: "unresolved" };
-            if (connections.length !== 1)
-                return { status: "ambiguous" };
-            const row = connections[0];
-            if (!row)
-                throw new VeilError("invalid_response");
-            return {
-                status: "verified",
-                completion: completion(row.tags, row.provider_config_key, row.connection_id),
-            };
-        },
-        async deleteConnection(locator, signal) {
-            const query = new URLSearchParams({
-                provider_config_key: options.integrationId,
-            });
-            const response = await request(`/connections/${encodeURIComponent(locator)}?${query.toString()}`, signal, { method: "DELETE" });
-            const raw = await body(response, signal);
-            // This pinned public endpoint reports absent as HTTP400, not a generic404.
-            if (response.status === 400) {
-                decode(absentSchema, raw);
-                return "absent";
-            }
-            requireSuccess(response);
-            decode(deletedSchema, raw);
-            return "deleted";
-        },
-        async readRepository(access, signal) {
-            // WHATWG URL normalizes dot segments, including percent-encoded dots.
-            if ([access.repository.owner, access.repository.name].some((part) => part === "." || part === ".."))
-                throw new VeilError("invalid_input");
-            const path = `/proxy/repos/${encodeURIComponent(access.repository.owner)}/${encodeURIComponent(access.repository.name)}`;
-            const response = await request(path, signal, {
-                headers: {
-                    "Connection-Id": access.locator,
-                    "Provider-Config-Key": options.integrationId,
-                },
-            });
-            if (response.status === 401) {
-                const evidence = Schema.decodeUnknownExit(Schema.fromJsonString(providerUnauthorizedSchema))(await body(response, signal));
-                throw new VeilError(Exit.isSuccess(evidence) ? "reconnect_required" : "unavailable");
-            }
-            requireSuccess(response);
-            return await body(response, signal);
-        },
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/veil",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Team-authorized credential custody and provider access",
   "type": "module",
@@ -11,14 +11,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./nango-git": {
-      "types": "./dist/nango-git.d.ts",
-      "import": "./dist/nango-git.js"
-    },
-    "./nango": {
-      "types": "./dist/nango.d.ts",
-      "import": "./dist/nango.js"
-    },
     "./model-credentials": {
       "types": "./dist/model-credentials.d.ts",
       "import": "./dist/model-credentials.js"
@@ -91,6 +83,10 @@
       "types": "./dist/connections/nango.d.ts",
       "import": "./dist/connections/nango.js"
     },
+    "./github-app": {
+      "types": "./dist/github-app.d.ts",
+      "import": "./dist/github-app.js"
+    },
     "./connections/source": {
       "types": "./dist/connections/source.d.ts",
       "import": "./dist/connections/source.js"

package/dist/nango-git.d.ts

@@ -1,19 +0,0 @@
-/** Private Team-owned Computer authorization, never an Agent metadata Grant. */
-export type GitRepositoryAccess = Readonly<{
-    repository: Readonly<{
-        owner: string;
-        name: string;
-    }>;
-    locator: string;
-    integrationId: string;
-}>;
-/** The caller must obtain fresh Computer/repository authorization before each
- * invocation. This adapter owns Nango control headers, not authorization state. */
-export declare function createNangoGitCustodian(options: Readonly<{
-    serverUrl: string;
-    apiKey: string;
-    integrationId: string;
-}>): {
-    /** Fetch, clone and push for one authorized repository. */
-    readGit(access: GitRepositoryAccess, request: Request): Promise<Response>;
-};

package/dist/nango-git.js

@@ -1,125 +0,0 @@
-import { VeilError } from "./index.js";
-import { bestEffortCleanup } from "./best-effort-cleanup.js";
-/** The four smart-HTTP exchanges this proxy admits for one repository, the
- * same operation table as the Artifacts custodian. Receive-pack is admitted
- * here; GitHub's own installation permission and branch rules decide it. */
-function gitOperation(request, url, base) {
-    for (const service of ["git-upload-pack", "git-receive-pack"]) {
-        const push = service === "git-receive-pack";
-        if (request.method === "GET" &&
-            url.pathname === `${base}/info/refs` &&
-            url.search === `?service=${service}`)
-            return {
-                push,
-                requestType: null,
-                responseType: `application/x-${service}-advertisement`,
-            };
-        if (request.method === "POST" &&
-            url.pathname === `${base}/${service}` &&
-            url.search === "")
-            return {
-                push,
-                requestType: `application/x-${service}-request`,
-                responseType: `application/x-${service}-result`,
-            };
-    }
-    return null;
-}
-/** GitHub refusals keep a typed code; vendor bodies never cross this port. */
-function upstreamRefusal(response) {
-    if (response.status === 429 ||
-        (response.status === 403 &&
-            response.headers.get("X-RateLimit-Remaining") === "0"))
-        return new VeilError("rate_limited");
-    // GitHub hides a repository outside the installation behind 404.
-    if (response.status === 404)
-        return new VeilError("repository_not_installed");
-    // A read-only installation token is refused write with 403.
-    if (response.status === 403)
-        return new VeilError("denied");
-    return new VeilError("unavailable");
-}
-/** The caller must obtain fresh Computer/repository authorization before each
- * invocation. This adapter owns Nango control headers, not authorization state. */
-export function createNangoGitCustodian(options) {
-    if (!URL.canParse(options.serverUrl))
-        throw new VeilError("invalid_input");
-    const server = new URL(options.serverUrl);
-    if (!options.apiKey ||
-        !options.integrationId ||
-        server.username ||
-        server.password ||
-        server.search ||
-        server.hash ||
-        server.pathname !== "/" ||
-        !["http:", "https:"].includes(server.protocol))
-        throw new VeilError("invalid_input");
-    return {
-        /** Fetch, clone and push for one authorized repository. */
-        async readGit(access, request) {
-            if (access.integrationId !== options.integrationId)
-                throw new VeilError("denied");
-            const url = new URL(request.url);
-            const parts = [access.repository.owner, access.repository.name];
-            if (!access.locator ||
-                parts.some((part) => !part || part === "." || part === ".."))
-                throw new VeilError("invalid_input");
-            const base = `/${parts.map(encodeURIComponent).join("/")}.git`;
-            const operation = gitOperation(request, url, base);
-            if (url.origin !== "https://github.com" ||
-                url.username ||
-                url.password ||
-                url.hash ||
-                operation === null)
-                throw new VeilError("denied");
-            const headers = new Headers({
-                Authorization: `Bearer ${options.apiKey}`,
-                "Provider-Config-Key": options.integrationId,
-                "Connection-Id": access.locator,
-            });
-            if (operation.requestType !== null) {
-                headers.set("Content-Type", operation.requestType);
-                headers.set("Nango-Proxy-Content-Type", operation.requestType);
-            }
-            const protocol = request.headers.get("Git-Protocol");
-            if (protocol !== null)
-                headers.set("Nango-Proxy-Git-Protocol", protocol);
-            let response;
-            try {
-                request.signal.throwIfAborted();
-                response = await fetch(new URL(`/proxy${url.pathname}${url.search}`, server), {
-                    method: request.method,
-                    headers,
-                    body: operation.requestType === null ? null : request.body,
-                    signal: request.signal,
-                    redirect: "manual",
-                    // Native Node fetch requires this for a stream; Workers accepts it.
-                    duplex: "half",
-                });
-            }
-            catch (cause) {
-                throw new VeilError(request.signal.aborted ? "cancelled" : "unavailable", cause);
-            }
-            if (!response.ok) {
-                await bestEffortCleanup("nango-git-response-body", () => response.body?.cancel() ?? Promise.resolve());
-                // Reads keep their retried `unavailable`; a push names its refusal.
-                throw operation.push
-                    ? upstreamRefusal(response)
-                    : new VeilError("unavailable");
-            }
-            if (response.headers.get("Content-Type") !== operation.responseType) {
-                await bestEffortCleanup("nango-git-response-body", () => response.body?.cancel() ?? Promise.resolve());
-                throw new VeilError("invalid_response");
-            }
-            // A protected-branch or hook refusal is GitHub's own report-status
-            // inside this 200 body; the Computer's git prints it unchanged.
-            return new Response(response.body, {
-                status: response.status,
-                headers: {
-                    "Content-Type": operation.responseType,
-                    "Cache-Control": "no-store",
-                },
-            });
-        },
-    };
-}