@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/bridge/stores/provider-store.js

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import { bridgeApiErrorModule } from "../../shared/bridge-api-error.js";
+const { BridgeApiError } = bridgeApiErrorModule;
+const nonEmptyString = (field) => z.string().trim().min(1, `${field} is required.`);
+const providerConfigSchema = z.object({}).catchall(z.unknown());
+const providerSchema = z.object({
+    id: nonEmptyString("id"),
+    kind: nonEmptyString("kind"),
+    label: nonEmptyString("label"),
+    enabled: z.boolean(),
+    config: providerConfigSchema,
+    createdAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true })
+});
+const createProviderRequestSchema = z
+    .object({
+    id: nonEmptyString("id"),
+    kind: nonEmptyString("kind"),
+    label: nonEmptyString("label"),
+    enabled: z.boolean().default(true),
+    config: providerConfigSchema.default({})
+})
+    .strict();
+const updateProviderRequestSchema = z
+    .object({
+    kind: nonEmptyString("kind").optional(),
+    label: nonEmptyString("label").optional(),
+    enabled: z.boolean().optional(),
+    config: providerConfigSchema.optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (Object.keys(value).length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "At least one mutable field must be provided."
+        });
+    }
+});
+const providerIdParamsSchema = z
+    .object({
+    id: nonEmptyString("id")
+})
+    .strict();
+const providerResponseSchema = z.object({
+    provider: providerSchema
+});
+const providerListResponseSchema = z.object({
+    providers: z.array(providerSchema)
+});
+const providerDeleteResponseSchema = z.object({
+    ok: z.literal(true),
+    id: z.string()
+});
+function createInMemoryProviderStore() {
+    const providers = new Map();
+    const store = {
+        list() {
+            return [...providers.values()].map(cloneProvider);
+        },
+        get(id) {
+            const provider = providers.get(id);
+            return provider ? cloneProvider(provider) : null;
+        },
+        create(input) {
+            if (providers.has(input.id)) {
+                throw new BridgeApiError({
+                    statusCode: 409,
+                    code: "provider_exists",
+                    message: `Provider '${input.id}' already exists.`
+                });
+            }
+            const timestamp = createTimestamp();
+            const provider = {
+                id: input.id,
+                kind: input.kind,
+                label: input.label,
+                enabled: input.enabled,
+                config: cloneConfig(input.config),
+                createdAt: timestamp,
+                updatedAt: timestamp
+            };
+            providers.set(provider.id, provider);
+            return cloneProvider(provider);
+        },
+        update(id, patch) {
+            const provider = providers.get(id);
+            if (!provider) {
+                throw missingProviderError(id);
+            }
+            const nextProvider = {
+                ...provider,
+                ...patch,
+                config: patch.config === undefined ? provider.config : cloneConfig(patch.config),
+                updatedAt: createTimestamp(provider.updatedAt)
+            };
+            providers.set(id, nextProvider);
+            return cloneProvider(nextProvider);
+        },
+        delete(id) {
+            if (!providers.delete(id)) {
+                throw missingProviderError(id);
+            }
+            return providerDeleteResponseSchema.parse({
+                ok: true,
+                id
+            });
+        }
+    };
+    return store;
+}
+function createTimestamp(previous) {
+    const previousTime = previous ? Date.parse(previous) : 0;
+    const now = Date.now();
+    const nextTime = previousTime >= now ? previousTime + 1 : now;
+    return new Date(nextTime).toISOString();
+}
+function cloneProvider(provider) {
+    return providerSchema.parse({
+        ...provider,
+        config: cloneConfig(provider.config)
+    });
+}
+function cloneConfig(config) {
+    return structuredClone(config);
+}
+function missingProviderError(id) {
+    return new BridgeApiError({
+        statusCode: 404,
+        code: "provider_not_found",
+        message: `Provider '${id}' was not found.`
+    });
+}
+export const providerStoreModule = {
+    providerSchema,
+    createProviderRequestSchema,
+    updateProviderRequestSchema,
+    providerIdParamsSchema,
+    providerResponseSchema,
+    providerListResponseSchema,
+    providerDeleteResponseSchema,
+    createInMemoryProviderStore
+};

package/packages/server/dist/bridge/stores/session-backed-provider-store.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderStore } from "./provider-store.ts";
+import type { SessionPackageStore } from "./session-package-store.ts";
+declare function createSessionBackedProviderStore(sessionPackageStore: SessionPackageStore): ProviderStore;
+export declare const sessionBackedProviderStoreModule: {
+    createSessionBackedProviderStore: typeof createSessionBackedProviderStore;
+};
+export {};

package/packages/server/dist/bridge/stores/session-backed-provider-store.js

@@ -0,0 +1,26 @@
+function createSessionBackedProviderStore(sessionPackageStore) {
+    return {
+        list() {
+            return sessionPackageStore.listProviders();
+        },
+        get(id) {
+            return sessionPackageStore.getProvider(id);
+        },
+        create(input) {
+            return sessionPackageStore.createProvider(input);
+        },
+        update(id, patch) {
+            return sessionPackageStore.updateProvider(id, patch);
+        },
+        delete(id) {
+            const deleted = sessionPackageStore.delete(id);
+            return {
+                ok: true,
+                id: deleted.providerId
+            };
+        }
+    };
+}
+export const sessionBackedProviderStoreModule = {
+    createSessionBackedProviderStore
+};

package/packages/server/dist/bridge/stores/session-package-store.d.ts

@@ -0,0 +1,286 @@
+import { z } from "zod";
+import type { CreateProviderRequest, ProviderRecord, UpdateProviderRequest } from "./provider-store.ts";
+declare const sessionPackageSchema: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodString;
+    capturedAt: z.ZodString;
+    origin: z.ZodString;
+    cookies: z.ZodDefault<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
+    localStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    sessionStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    headers: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    integration: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaultModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    transport: z.ZodOptional<z.ZodObject<{
+        family: z.ZodEnum<{
+            "http-sse": "http-sse";
+            "http-json": "http-json";
+            "http-connect": "http-connect";
+        }>;
+        prompt: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        binding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        session: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        request: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        response: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        seedBinding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        bootstrap: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        preflight: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const sessionPackageDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    providerId: z.ZodString;
+}, z.core.$strict>;
+declare const sessionPackageMetadataSchema: z.ZodObject<{
+    handle: z.ZodString;
+    providerId: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    capturedAt: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodString>;
+    hasSessionPackage: z.ZodBoolean;
+    createdAt: z.ZodString;
+    lastUsedAt: z.ZodOptional<z.ZodString>;
+    lastVerifiedAt: z.ZodOptional<z.ZodString>;
+    idleExpiresAt: z.ZodOptional<z.ZodString>;
+    absoluteExpiresAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        revoked: "revoked";
+        invalid: "invalid";
+    }>;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+declare const installedProviderPackageSchema: z.ZodObject<{
+    provider: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        label: z.ZodString;
+        enabled: z.ZodBoolean;
+        config: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    session: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodString;
+        capturedAt: z.ZodString;
+        origin: z.ZodString;
+        cookies: z.ZodDefault<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
+        localStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        sessionStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        headers: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        integration: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaultModel: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        transport: z.ZodOptional<z.ZodObject<{
+            family: z.ZodEnum<{
+                "http-sse": "http-sse";
+                "http-json": "http-json";
+                "http-connect": "http-connect";
+            }>;
+            prompt: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            binding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            session: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            request: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            response: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            seedBinding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            bootstrap: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            preflight: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type SessionPackageRecord = z.infer<typeof sessionPackageSchema>;
+type SessionPackageMetadata = z.infer<typeof sessionPackageMetadataSchema>;
+type SessionPackageDeleteResponse = z.infer<typeof sessionPackageDeleteResponseSchema>;
+type InstalledProviderPackage = z.infer<typeof installedProviderPackageSchema>;
+type SessionPackageStore = {
+    listProviders(): ProviderRecord[];
+    getProvider(providerId: string): ProviderRecord | null;
+    createProvider(input: CreateProviderRequest): ProviderRecord;
+    updateProvider(providerId: string, patch: UpdateProviderRequest): ProviderRecord;
+    get(providerId: string): SessionPackageRecord | null;
+    getStatus(providerId: string): SessionPackageMetadata | null;
+    put(providerId: string, value: SessionPackageRecord): SessionPackageMetadata;
+    delete(providerId: string): SessionPackageDeleteResponse;
+    deleteSession(providerId: string): SessionPackageDeleteResponse;
+    listPackages(): InstalledProviderPackage[];
+    getPackage(providerId: string): InstalledProviderPackage | null;
+};
+declare function createInMemorySessionPackageStore(): SessionPackageStore;
+declare function buildSessionPackageStatus(providerId: string, stored: SessionPackageMetadata | null): {
+    ok: true;
+    providerId: string;
+    hasSessionPackage: boolean;
+    source?: string | undefined;
+    capturedAt?: string | undefined;
+    origin?: string | undefined;
+};
+declare function cloneProvider(provider: ProviderRecord): ProviderRecord;
+declare function cloneConfig(config: Record<string, unknown>): Record<string, unknown>;
+declare function cloneSessionPackage(value: SessionPackageRecord): SessionPackageRecord;
+declare function cloneSessionPackageMetadata(value: SessionPackageMetadata): SessionPackageMetadata;
+declare function cloneInstalledProviderPackage(value: InstalledProviderPackage): InstalledProviderPackage;
+declare function buildSessionPackageMetadata(providerId: string, session: SessionPackageRecord | null, input: {
+    existing: SessionPackageMetadata | null;
+    now: string;
+    handle?: string;
+}): {
+    handle: string;
+    providerId: string;
+    hasSessionPackage: boolean;
+    createdAt: string;
+    status: "active" | "expired" | "revoked" | "invalid";
+    version: number;
+    source?: string | undefined;
+    capturedAt?: string | undefined;
+    origin?: string | undefined;
+    lastUsedAt?: string | undefined;
+    lastVerifiedAt?: string | undefined;
+    idleExpiresAt?: string | undefined;
+    absoluteExpiresAt?: string | undefined;
+};
+declare function inferProviderFromSessionPackage(input: {
+    providerId: string;
+    value: SessionPackageRecord;
+    existing: ProviderRecord | null;
+    now: string;
+}): {
+    id: string;
+    kind: string;
+    label: string;
+    enabled: boolean;
+    config: {
+        [x: string]: unknown;
+    };
+    createdAt: string;
+    updatedAt: string;
+};
+export declare const sessionPackageStoreModule: {
+    sessionPackageSchema: z.ZodObject<{
+        schemaVersion: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodString;
+        capturedAt: z.ZodString;
+        origin: z.ZodString;
+        cookies: z.ZodDefault<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
+        localStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        sessionStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        headers: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        integration: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaultModel: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        transport: z.ZodOptional<z.ZodObject<{
+            family: z.ZodEnum<{
+                "http-sse": "http-sse";
+                "http-json": "http-json";
+                "http-connect": "http-connect";
+            }>;
+            prompt: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            binding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            session: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            request: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            response: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            seedBinding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            bootstrap: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            preflight: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    sessionPackageStatusResponseSchema: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        providerId: z.ZodString;
+        hasSessionPackage: z.ZodBoolean;
+        source: z.ZodOptional<z.ZodString>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+        origin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    sessionPackageDeleteResponseSchema: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        providerId: z.ZodString;
+    }, z.core.$strict>;
+    sessionPackageMetadataSchema: z.ZodObject<{
+        handle: z.ZodString;
+        providerId: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+        origin: z.ZodOptional<z.ZodString>;
+        hasSessionPackage: z.ZodBoolean;
+        createdAt: z.ZodString;
+        lastUsedAt: z.ZodOptional<z.ZodString>;
+        lastVerifiedAt: z.ZodOptional<z.ZodString>;
+        idleExpiresAt: z.ZodOptional<z.ZodString>;
+        absoluteExpiresAt: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            expired: "expired";
+            revoked: "revoked";
+            invalid: "invalid";
+        }>;
+        version: z.ZodNumber;
+    }, z.core.$strict>;
+    installedProviderPackageSchema: z.ZodObject<{
+        provider: z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            label: z.ZodString;
+            enabled: z.ZodBoolean;
+            config: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>;
+        session: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodString;
+            capturedAt: z.ZodString;
+            origin: z.ZodString;
+            cookies: z.ZodDefault<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
+            localStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            sessionStorage: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            headers: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            integration: z.ZodOptional<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                defaultModel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            transport: z.ZodOptional<z.ZodObject<{
+                family: z.ZodEnum<{
+                    "http-sse": "http-sse";
+                    "http-json": "http-json";
+                    "http-connect": "http-connect";
+                }>;
+                prompt: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                binding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                session: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                request: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                response: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                seedBinding: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                bootstrap: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+                preflight: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createInMemorySessionPackageStore: typeof createInMemorySessionPackageStore;
+    buildSessionPackageStatus: typeof buildSessionPackageStatus;
+    cloneProvider: typeof cloneProvider;
+    cloneConfig: typeof cloneConfig;
+    cloneSessionPackage: typeof cloneSessionPackage;
+    cloneSessionPackageMetadata: typeof cloneSessionPackageMetadata;
+    cloneInstalledProviderPackage: typeof cloneInstalledProviderPackage;
+    buildSessionPackageMetadata: typeof buildSessionPackageMetadata;
+    inferProviderFromSessionPackage: typeof inferProviderFromSessionPackage;
+};
+export type { InstalledProviderPackage, SessionPackageDeleteResponse, SessionPackageMetadata, SessionPackageRecord, SessionPackageStore };