@zeke-02/tinfoil 0.0.2

package/dist/esm/fetch-adapter.js

@@ -0,0 +1,23 @@
+/**
+ * Fetch adapter for Tauri v2
+ *
+ * This module provides a centralized fetch implementation for Tauri v2.
+ * For testing purposes, the fetch function can be overridden by setting
+ * the global __TINFOIL_TEST_FETCH__ property.
+ */
+import { fetch as tauriFetch } from "@tauri-apps/plugin-http";
+/**
+ * Get the fetch implementation to use.
+ * In tests, this can be overridden by setting globalThis.__TINFOIL_TEST_FETCH__
+ */
+export function getFetch() {
+    if (typeof globalThis.__TINFOIL_TEST_FETCH__ === "function") {
+        return globalThis.__TINFOIL_TEST_FETCH__;
+    }
+    return tauriFetch;
+}
+/**
+ * The fetch function to use throughout the application.
+ * Uses Tauri's fetch by default, but can be mocked for testing.
+ */
+export const fetch = getFetch();

package/dist/esm/index.browser.d.ts

@@ -0,0 +1,7 @@
+export { TinfoilAI } from "./tinfoilai";
+export { TinfoilAI as default } from "./tinfoilai";
+export * from "./verifier";
+export * from "./ai-sdk-provider";
+export * from "./config";
+export { SecureClient } from "./secure-client";
+export { UnverifiedClient } from "./unverified-client";

package/dist/esm/index.browser.js

@@ -0,0 +1,8 @@
+// Browser-safe entry point: avoids Node built-ins
+export { TinfoilAI } from "./tinfoilai";
+export { TinfoilAI as default } from "./tinfoilai";
+export * from "./verifier";
+export * from "./ai-sdk-provider";
+export * from "./config";
+export { SecureClient } from "./secure-client";
+export { UnverifiedClient } from "./unverified-client";

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export { TinfoilAI } from "./tinfoilai";
+export { TinfoilAI as default } from "./tinfoilai";
+export * from "./verifier";
+export * from "./ai-sdk-provider";
+export * from "./config";
+export { SecureClient } from "./secure-client";
+export { UnverifiedClient } from "./unverified-client";
+export { type Uploadable, toFile, APIPromise, PagePromise, OpenAIError, APIError, APIConnectionError, APIConnectionTimeoutError, APIUserAbortError, NotFoundError, ConflictError, RateLimitError, BadRequestError, AuthenticationError, InternalServerError, PermissionDeniedError, UnprocessableEntityError, } from "openai";

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+// Re-export the TinfoilAI class
+export { TinfoilAI } from "./tinfoilai";
+export { TinfoilAI as default } from "./tinfoilai";
+// Export verifier
+export * from "./verifier";
+export * from "./ai-sdk-provider";
+export * from "./config";
+export { SecureClient } from "./secure-client";
+export { UnverifiedClient } from "./unverified-client";
+// Re-export OpenAI utility types and classes that users might need
+// Using public exports from the main OpenAI package instead of deep imports
+export { toFile, APIPromise, PagePromise, OpenAIError, APIError, APIConnectionError, APIConnectionTimeoutError, APIUserAbortError, NotFoundError, ConflictError, RateLimitError, BadRequestError, AuthenticationError, InternalServerError, PermissionDeniedError, UnprocessableEntityError, } from "openai";

package/dist/esm/pinned-tls-fetch.d.ts

@@ -0,0 +1 @@
+export declare function createPinnedTlsFetch(baseURL: string, expectedFingerprintHex: string): typeof fetch;

package/dist/esm/pinned-tls-fetch.js

@@ -0,0 +1,110 @@
+import https from "https";
+import { checkServerIdentity as tlsCheckServerIdentity } from "tls";
+import { X509Certificate, createHash } from "crypto";
+import { Readable } from "stream";
+export function createPinnedTlsFetch(baseURL, expectedFingerprintHex) {
+    return (async (input, init) => {
+        // Normalize URL with base URL support
+        const makeURL = (value) => {
+            if (typeof value === "string")
+                return new URL(value, baseURL);
+            if (value instanceof URL)
+                return value;
+            return new URL(value.url, baseURL);
+        };
+        const url = makeURL(input);
+        if (url.protocol !== "https:") {
+            throw new Error(`HTTP connections are not allowed. Use HTTPS. URL: ${url.toString()}`);
+        }
+        // Gather method and headers
+        const method = (init?.method || input.method || "GET").toUpperCase();
+        const headers = new Headers(init?.headers || input?.headers || {});
+        const headerObj = {};
+        headers.forEach((v, k) => {
+            headerObj[k] = v;
+        });
+        // Resolve body
+        let body = init?.body;
+        if (!body && input instanceof Request) {
+            // If the original was a Request with a body, read it
+            try {
+                const buf = await input.arrayBuffer();
+                if (buf && buf.byteLength)
+                    body = Buffer.from(buf);
+            }
+            catch { }
+        }
+        // Convert web streams to Node streams if needed
+        if (body && typeof body.getReader === "function") {
+            body = Readable.fromWeb(body);
+        }
+        if (body instanceof ArrayBuffer) {
+            body = Buffer.from(body);
+        }
+        if (ArrayBuffer.isView(body)) {
+            body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+        }
+        const requestOptions = {
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : 443,
+            path: `${url.pathname}${url.search}`,
+            method,
+            headers: headerObj,
+            checkServerIdentity: (host, cert) => {
+                const raw = cert.raw;
+                if (!raw) {
+                    return new Error("Certificate raw bytes are unavailable for pinning");
+                }
+                const x509 = new X509Certificate(raw);
+                const publicKeyDer = x509.publicKey.export({ type: "spki", format: "der" });
+                const fp = createHash("sha256").update(publicKeyDer).digest("hex");
+                if (fp !== expectedFingerprintHex) {
+                    return new Error(`Certificate public key fingerprint mismatch. Expected: ${expectedFingerprintHex}, Got: ${fp}`);
+                }
+                return tlsCheckServerIdentity(host, cert);
+            },
+        };
+        const { signal } = init || {};
+        const res = await new Promise((resolve, reject) => {
+            const req = https.request(requestOptions, resolve);
+            req.on("error", reject);
+            if (signal) {
+                if (signal.aborted) {
+                    req.destroy(new Error("Request aborted"));
+                    return;
+                }
+                signal.addEventListener("abort", () => req.destroy(new Error("Request aborted")));
+            }
+            if (body === undefined || body === null) {
+                req.end();
+            }
+            else if (typeof body === "string" || Buffer.isBuffer(body) || ArrayBuffer.isView(body)) {
+                req.end(body);
+            }
+            else if (typeof body.pipe === "function") {
+                body.pipe(req);
+            }
+            else {
+                // Fallback: try to serialize objects
+                req.end(String(body));
+            }
+        });
+        const responseHeaders = new Headers();
+        for (const [k, v] of Object.entries(res.headers)) {
+            if (Array.isArray(v)) {
+                v.forEach(item => responseHeaders.append(k, item));
+            }
+            else if (v != null) {
+                responseHeaders.set(k, String(v));
+            }
+        }
+        // Convert Node stream to Web ReadableStream
+        const webStream = Readable.toWeb(res);
+        return new Response(webStream, {
+            status: res.statusCode || 0,
+            statusText: res.statusMessage || "",
+            headers: responseHeaders,
+        });
+    });
+}

package/dist/esm/secure-client.d.ts

@@ -0,0 +1,20 @@
+import type { VerificationDocument } from "./verifier";
+interface SecureClientOptions {
+    baseURL?: string;
+    enclaveURL?: string;
+    configRepo?: string;
+}
+export declare class SecureClient {
+    private initPromise;
+    private verificationDocument;
+    private _fetch;
+    private readonly baseURL?;
+    private readonly enclaveURL?;
+    private readonly configRepo?;
+    constructor(options?: SecureClientOptions);
+    ready(): Promise<void>;
+    private initSecureClient;
+    getVerificationDocument(): Promise<VerificationDocument>;
+    get fetch(): typeof fetch;
+}
+export {};

package/dist/esm/secure-client.js

@@ -0,0 +1,123 @@
+import { Verifier } from "./verifier";
+import { TINFOIL_CONFIG } from "./config";
+import { createSecureFetch } from "./secure-fetch";
+export class SecureClient {
+    constructor(options = {}) {
+        this.initPromise = null;
+        this.verificationDocument = null;
+        this._fetch = null;
+        this.baseURL = options.baseURL || TINFOIL_CONFIG.INFERENCE_BASE_URL;
+        this.enclaveURL = options.enclaveURL || TINFOIL_CONFIG.ENCLAVE_URL;
+        this.configRepo = options.configRepo || TINFOIL_CONFIG.INFERENCE_PROXY_REPO;
+    }
+    async ready() {
+        if (!this.initPromise) {
+            this.initPromise = this.initSecureClient();
+        }
+        return this.initPromise;
+    }
+    async initSecureClient() {
+        const verifier = new Verifier({
+            serverURL: this.enclaveURL,
+            configRepo: this.configRepo,
+        });
+        try {
+            await verifier.verify();
+            const doc = verifier.getVerificationDocument();
+            if (!doc) {
+                throw new Error("Verification document not available after successful verification");
+            }
+            this.verificationDocument = doc;
+            // Extract keys from the verification document
+            const { hpkePublicKey, tlsPublicKeyFingerprint } = this.verificationDocument.enclaveMeasurement;
+            try {
+                this._fetch = createSecureFetch(this.baseURL, this.enclaveURL, hpkePublicKey, tlsPublicKeyFingerprint);
+            }
+            catch (transportError) {
+                this.verificationDocument.steps.createTransport = {
+                    status: "failed",
+                    error: transportError.message,
+                };
+                this.verificationDocument.securityVerified = false;
+                throw transportError;
+            }
+        }
+        catch (error) {
+            const doc = verifier.getVerificationDocument();
+            if (doc) {
+                this.verificationDocument = doc;
+            }
+            else {
+                this.verificationDocument = {
+                    configRepo: this.configRepo,
+                    enclaveHost: new URL(this.enclaveURL).hostname,
+                    releaseDigest: "",
+                    codeMeasurement: { type: "", registers: [] },
+                    enclaveMeasurement: { measurement: { type: "", registers: [] } },
+                    securityVerified: false,
+                    steps: {
+                        fetchDigest: { status: "pending" },
+                        verifyCode: { status: "pending" },
+                        verifyEnclave: { status: "pending" },
+                        compareMeasurements: { status: "pending" },
+                        otherError: { status: "failed", error: error.message },
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async getVerificationDocument() {
+        if (!this.initPromise) {
+            await this.ready();
+        }
+        await this.initPromise.catch(() => { });
+        if (!this.verificationDocument) {
+            throw new Error("Verification document unavailable: client not verified yet");
+        }
+        return this.verificationDocument;
+    }
+    get fetch() {
+        return async (input, init) => {
+            await this.ready();
+            try {
+                return await this._fetch(input, init);
+            }
+            catch (error) {
+                if (this.verificationDocument) {
+                    const errorMessage = error.message;
+                    if (errorMessage.includes("HPKE public key mismatch")) {
+                        this.verificationDocument.steps.verifyHPKEKey = {
+                            status: "failed",
+                            error: errorMessage,
+                        };
+                        this.verificationDocument.securityVerified = false;
+                    }
+                    else if (errorMessage.includes("Transport initialization failed") ||
+                        errorMessage.includes("Request initialization failed")) {
+                        this.verificationDocument.steps.createTransport = {
+                            status: "failed",
+                            error: errorMessage,
+                        };
+                        this.verificationDocument.securityVerified = false;
+                    }
+                    else if (errorMessage.includes("Failed to get HPKE key")) {
+                        this.verificationDocument.steps.verifyHPKEKey = {
+                            status: "failed",
+                            error: errorMessage,
+                        };
+                        this.verificationDocument.securityVerified = false;
+                    }
+                    else {
+                        this.verificationDocument.steps.otherError = {
+                            status: "failed",
+                            error: errorMessage,
+                        };
+                        this.verificationDocument.securityVerified = false;
+                    }
+                }
+                throw error;
+            }
+        };
+    }
+}

package/dist/esm/secure-fetch.browser.d.ts

@@ -0,0 +1 @@
+export declare function createSecureFetch(baseURL: string, enclaveURL?: string, hpkePublicKey?: string, tlsPublicKeyFingerprint?: string): typeof fetch;

package/dist/esm/secure-fetch.browser.js

@@ -0,0 +1,10 @@
+import { createEncryptedBodyFetch } from "./encrypted-body-fetch";
+export function createSecureFetch(baseURL, enclaveURL, hpkePublicKey, tlsPublicKeyFingerprint) {
+    if (hpkePublicKey) {
+        return createEncryptedBodyFetch(baseURL, hpkePublicKey, enclaveURL);
+    }
+    else {
+        throw new Error("HPKE public key not available and TLS-only verification is not supported in browsers. " +
+            "Only HPKE-enabled enclaves can be used in browser environments.");
+    }
+}

package/dist/esm/secure-fetch.d.ts

@@ -0,0 +1 @@
+export declare function createSecureFetch(baseURL: string, enclaveURL?: string, hpkePublicKey?: string, tlsPublicKeyFingerprint?: string): typeof fetch;

package/dist/esm/secure-fetch.js

@@ -0,0 +1,22 @@
+import { createEncryptedBodyFetch } from "./encrypted-body-fetch";
+import { createPinnedTlsFetch } from "./pinned-tls-fetch";
+import { isRealBrowser } from "./env";
+export function createSecureFetch(baseURL, enclaveURL, hpkePublicKey, tlsPublicKeyFingerprint) {
+    let fetchFunction;
+    if (hpkePublicKey) {
+        fetchFunction = createEncryptedBodyFetch(baseURL, hpkePublicKey, enclaveURL);
+    }
+    else {
+        // HPKE not available: check if we're in a browser
+        if (isRealBrowser()) {
+            throw new Error("HPKE public key not available and TLS-only verification is not supported in browsers. " +
+                "Only HPKE-enabled enclaves can be used in browser environments.");
+        }
+        // Node.js environment: fall back to TLS-only verification using pinned TLS fetch
+        if (!tlsPublicKeyFingerprint) {
+            throw new Error("Neither HPKE public key nor TLS public key fingerprint available for verification");
+        }
+        fetchFunction = createPinnedTlsFetch(baseURL, tlsPublicKeyFingerprint);
+    }
+    return fetchFunction;
+}

package/dist/esm/tinfoilai.d.ts

@@ -0,0 +1,54 @@
+import OpenAI from "openai";
+import type { Audio, Beta, Chat, Embeddings, Files, FineTuning, Images, Models, Moderations, Responses } from "openai/resources";
+import type { VerificationDocument } from "./verifier";
+interface TinfoilAIOptions {
+    apiKey?: string;
+    baseURL?: string;
+    enclaveURL?: string;
+    configRepo?: string;
+    [key: string]: any;
+}
+export declare class TinfoilAI {
+    private client?;
+    private clientPromise;
+    private readyPromise?;
+    private configRepo?;
+    private secureClient;
+    private verificationDocument?;
+    apiKey?: string;
+    baseURL?: string;
+    enclaveURL?: string;
+    constructor(options?: TinfoilAIOptions);
+    ready(): Promise<void>;
+    private initClient;
+    private createOpenAIClient;
+    private ensureReady;
+    getVerificationDocument(): Promise<VerificationDocument>;
+    get chat(): Chat;
+    get files(): Files;
+    get fineTuning(): FineTuning;
+    get images(): Images;
+    get audio(): Audio;
+    get responses(): Responses;
+    get embeddings(): Embeddings;
+    get models(): Models;
+    get moderations(): Moderations;
+    get beta(): Beta;
+}
+export declare namespace TinfoilAI {
+    export import Chat = OpenAI.Chat;
+    export import Audio = OpenAI.Audio;
+    export import Beta = OpenAI.Beta;
+    export import Batches = OpenAI.Batches;
+    export import Completions = OpenAI.Completions;
+    export import Embeddings = OpenAI.Embeddings;
+    export import Files = OpenAI.Files;
+    export import FineTuning = OpenAI.FineTuning;
+    export import Images = OpenAI.Images;
+    export import Models = OpenAI.Models;
+    export import Moderations = OpenAI.Moderations;
+    export import Responses = OpenAI.Responses;
+    export import Uploads = OpenAI.Uploads;
+    export import VectorStores = OpenAI.VectorStores;
+}
+export {};

package/dist/esm/tinfoilai.js

@@ -0,0 +1,134 @@
+import OpenAI from "openai";
+import { SecureClient } from "./secure-client";
+import { TINFOIL_CONFIG } from "./config";
+import { isRealBrowser } from "./env";
+function createAsyncProxy(promise) {
+    return new Proxy({}, {
+        get(target, prop) {
+            return new Proxy(() => { }, {
+                get(_, nestedProp) {
+                    return (...args) => promise.then((obj) => {
+                        const value = obj[prop][nestedProp];
+                        return typeof value === "function"
+                            ? value.apply(obj[prop], args)
+                            : value;
+                    });
+                },
+                apply(_, __, args) {
+                    return promise.then((obj) => {
+                        const value = obj[prop];
+                        return typeof value === "function" ? value.apply(obj, args) : value;
+                    });
+                },
+            });
+        },
+    });
+}
+export class TinfoilAI {
+    constructor(options = {}) {
+        const openAIOptions = { ...options };
+        // In browser builds, never read secrets from process.env to avoid
+        // leaking credentials into client bundles. Require explicit apiKey.
+        if (options.apiKey) {
+            openAIOptions.apiKey = options.apiKey;
+        }
+        else if (!isRealBrowser() && process.env.TINFOIL_API_KEY) {
+            openAIOptions.apiKey = process.env.TINFOIL_API_KEY;
+        }
+        this.apiKey = openAIOptions.apiKey;
+        this.baseURL = options.baseURL || TINFOIL_CONFIG.INFERENCE_BASE_URL;
+        this.enclaveURL = options.enclaveURL || TINFOIL_CONFIG.ENCLAVE_URL;
+        this.configRepo = options.configRepo || TINFOIL_CONFIG.INFERENCE_PROXY_REPO;
+        this.secureClient = new SecureClient({
+            baseURL: this.baseURL,
+            enclaveURL: this.enclaveURL,
+            configRepo: this.configRepo,
+        });
+        this.clientPromise = this.initClient(openAIOptions);
+    }
+    async ready() {
+        if (!this.readyPromise) {
+            this.readyPromise = (async () => {
+                this.client = await this.clientPromise;
+            })();
+        }
+        return this.readyPromise;
+    }
+    async initClient(options) {
+        return this.createOpenAIClient(options);
+    }
+    async createOpenAIClient(options = {}) {
+        await this.secureClient.ready();
+        this.verificationDocument = await this.secureClient.getVerificationDocument();
+        if (!this.verificationDocument) {
+            throw new Error("Verification document not available after successful verification");
+        }
+        const clientOptions = {
+            ...options,
+            baseURL: this.baseURL,
+            fetch: this.secureClient.fetch,
+        };
+        if (isRealBrowser() || options.dangerouslyAllowBrowser === true) {
+            clientOptions.dangerouslyAllowBrowser = true;
+        }
+        return new OpenAI(clientOptions);
+    }
+    async ensureReady() {
+        await this.ready();
+        return this.client;
+    }
+    async getVerificationDocument() {
+        await this.ready();
+        if (!this.verificationDocument) {
+            throw new Error("Verification document unavailable: client not verified yet");
+        }
+        return this.verificationDocument;
+    }
+    get chat() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.chat));
+    }
+    get files() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.files));
+    }
+    get fineTuning() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.fineTuning));
+    }
+    get images() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.images));
+    }
+    get audio() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.audio));
+    }
+    get responses() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.responses));
+    }
+    get embeddings() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.embeddings));
+    }
+    get models() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.models));
+    }
+    get moderations() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.moderations));
+    }
+    get beta() {
+        return createAsyncProxy(this.ensureReady().then((client) => client.beta));
+    }
+}
+// Namespace declaration merge to add OpenAI types to TinfoilAI
+(function (TinfoilAI) {
+    TinfoilAI.Chat = OpenAI.Chat;
+    TinfoilAI.Audio = OpenAI.Audio;
+    TinfoilAI.Beta = OpenAI.Beta;
+    TinfoilAI.Batches = OpenAI.Batches;
+    TinfoilAI.Completions = OpenAI.Completions;
+    TinfoilAI.Embeddings = OpenAI.Embeddings;
+    TinfoilAI.Files = OpenAI.Files;
+    TinfoilAI.FineTuning = OpenAI.FineTuning;
+    TinfoilAI.Images = OpenAI.Images;
+    TinfoilAI.Models = OpenAI.Models;
+    TinfoilAI.Moderations = OpenAI.Moderations;
+    TinfoilAI.Responses = OpenAI.Responses;
+    TinfoilAI.Uploads = OpenAI.Uploads;
+    TinfoilAI.VectorStores = OpenAI.VectorStores;
+})(TinfoilAI || (TinfoilAI = {}));

package/dist/esm/unverified-client.d.ts

@@ -0,0 +1,18 @@
+interface UnverifiedClientOptions {
+    baseURL?: string;
+    enclaveURL?: string;
+    configRepo?: string;
+}
+export declare class UnverifiedClient {
+    private initPromise;
+    private _fetch;
+    private readonly baseURL;
+    private readonly enclaveURL;
+    private readonly configRepo;
+    constructor(options?: UnverifiedClientOptions);
+    ready(): Promise<void>;
+    private initUnverifiedClient;
+    getVerificationDocument(): Promise<void>;
+    get fetch(): typeof fetch;
+}
+export {};

package/dist/esm/unverified-client.js

@@ -0,0 +1,33 @@
+import { TINFOIL_CONFIG } from "./config";
+import { createEncryptedBodyFetch } from "./encrypted-body-fetch";
+export class UnverifiedClient {
+    constructor(options = {}) {
+        this.initPromise = null;
+        this._fetch = null;
+        this.baseURL = options.baseURL || TINFOIL_CONFIG.INFERENCE_BASE_URL;
+        this.enclaveURL = options.enclaveURL || TINFOIL_CONFIG.ENCLAVE_URL;
+        this.configRepo = options.configRepo || TINFOIL_CONFIG.INFERENCE_PROXY_REPO;
+    }
+    async ready() {
+        if (!this.initPromise) {
+            this.initPromise = this.initUnverifiedClient();
+        }
+        return this.initPromise;
+    }
+    async initUnverifiedClient() {
+        this._fetch = createEncryptedBodyFetch(this.baseURL, undefined, this.enclaveURL);
+    }
+    async getVerificationDocument() {
+        if (!this.initPromise) {
+            await this.ready();
+        }
+        await this.initPromise;
+        throw new Error("Verification document unavailable: this version of the client is unverified");
+    }
+    get fetch() {
+        return async (input, init) => {
+            await this.ready();
+            return this._fetch(input, init);
+        };
+    }
+}