@uncensoredcode/openbridge 0.1.0

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

@@ -0,0 +1,120 @@
+import { z } from "zod";
+declare const sessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    providerId: z.ZodNullable<z.ZodString>;
+    label: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const createSessionRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    providerId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strict>;
+declare const updateSessionRequestSchema: z.ZodObject<{
+    providerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strict>;
+type SessionRecord = z.infer<typeof sessionSchema>;
+type CreateSessionRequest = z.infer<typeof createSessionRequestSchema>;
+type UpdateSessionRequest = z.infer<typeof updateSessionRequestSchema>;
+declare function createInMemorySessionStore(): {
+    list(): {
+        id: string;
+        providerId: string | null;
+        label: string | null;
+        metadata: {
+            [x: string]: unknown;
+        };
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    get(id: string): {
+        id: string;
+        providerId: string | null;
+        label: string | null;
+        metadata: {
+            [x: string]: unknown;
+        };
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+    create(input: CreateSessionRequest): {
+        id: string;
+        providerId: string | null;
+        label: string | null;
+        metadata: {
+            [x: string]: unknown;
+        };
+        createdAt: string;
+        updatedAt: string;
+    };
+    update(id: string, patch: UpdateSessionRequest): {
+        id: string;
+        providerId: string | null;
+        label: string | null;
+        metadata: {
+            [x: string]: unknown;
+        };
+        createdAt: string;
+        updatedAt: string;
+    };
+    delete(id: string): {
+        ok: true;
+        id: string;
+    };
+};
+type SessionStore = ReturnType<typeof createInMemorySessionStore>;
+export declare const sessionStoreModule: {
+    sessionSchema: z.ZodObject<{
+        id: z.ZodString;
+        providerId: z.ZodNullable<z.ZodString>;
+        label: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    createSessionRequestSchema: z.ZodObject<{
+        id: z.ZodString;
+        providerId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        metadata: z.ZodDefault<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strict>;
+    updateSessionRequestSchema: z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>;
+    }, z.core.$strict>;
+    sessionIdParamsSchema: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    sessionResponseSchema: z.ZodObject<{
+        session: z.ZodObject<{
+            id: z.ZodString;
+            providerId: z.ZodNullable<z.ZodString>;
+            label: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    sessionListResponseSchema: z.ZodObject<{
+        sessions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            providerId: z.ZodNullable<z.ZodString>;
+            label: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    sessionDeleteResponseSchema: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    createInMemorySessionStore: typeof createInMemorySessionStore;
+};
+export type { CreateSessionRequest, SessionRecord, SessionStore, UpdateSessionRequest };

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

@@ -0,0 +1,139 @@
+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 nullableNonEmptyString = (field) => nonEmptyString(field).nullable();
+const metadataSchema = z.object({}).catchall(z.unknown());
+const sessionSchema = z.object({
+    id: nonEmptyString("id"),
+    providerId: nullableNonEmptyString("providerId"),
+    label: nullableNonEmptyString("label"),
+    metadata: metadataSchema,
+    createdAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true })
+});
+const createSessionRequestSchema = z
+    .object({
+    id: nonEmptyString("id"),
+    providerId: nullableNonEmptyString("providerId").default(null),
+    label: nullableNonEmptyString("label").default(null),
+    metadata: metadataSchema.default({})
+})
+    .strict();
+const updateSessionRequestSchema = z
+    .object({
+    providerId: nullableNonEmptyString("providerId").optional(),
+    label: nullableNonEmptyString("label").optional(),
+    metadata: metadataSchema.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 sessionIdParamsSchema = z
+    .object({
+    id: nonEmptyString("id")
+})
+    .strict();
+const sessionResponseSchema = z.object({
+    session: sessionSchema
+});
+const sessionListResponseSchema = z.object({
+    sessions: z.array(sessionSchema)
+});
+const sessionDeleteResponseSchema = z.object({
+    ok: z.literal(true),
+    id: z.string()
+});
+function createInMemorySessionStore() {
+    const sessions = new Map();
+    return {
+        list() {
+            return [...sessions.values()].map(cloneSession);
+        },
+        get(id) {
+            const session = sessions.get(id);
+            return session ? cloneSession(session) : null;
+        },
+        create(input) {
+            if (sessions.has(input.id)) {
+                throw new BridgeApiError({
+                    statusCode: 409,
+                    code: "session_exists",
+                    message: `Session '${input.id}' already exists.`
+                });
+            }
+            const timestamp = createTimestamp();
+            const session = {
+                id: input.id,
+                providerId: input.providerId,
+                label: input.label,
+                metadata: cloneMetadata(input.metadata),
+                createdAt: timestamp,
+                updatedAt: timestamp
+            };
+            sessions.set(session.id, session);
+            return cloneSession(session);
+        },
+        update(id, patch) {
+            const session = sessions.get(id);
+            if (!session) {
+                throw missingSessionError(id);
+            }
+            const nextSession = {
+                ...session,
+                ...patch,
+                metadata: patch.metadata === undefined ? session.metadata : cloneMetadata(patch.metadata),
+                updatedAt: createTimestamp(session.updatedAt)
+            };
+            sessions.set(id, nextSession);
+            return cloneSession(nextSession);
+        },
+        delete(id) {
+            if (!sessions.delete(id)) {
+                throw missingSessionError(id);
+            }
+            return sessionDeleteResponseSchema.parse({
+                ok: true,
+                id
+            });
+        }
+    };
+}
+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 cloneSession(session) {
+    return sessionSchema.parse({
+        ...session,
+        metadata: cloneMetadata(session.metadata)
+    });
+}
+function cloneMetadata(metadata) {
+    return structuredClone(metadata);
+}
+function missingSessionError(id) {
+    return new BridgeApiError({
+        statusCode: 404,
+        code: "session_not_found",
+        message: `Session '${id}' was not found.`
+    });
+}
+export const sessionStoreModule = {
+    sessionSchema,
+    createSessionRequestSchema,
+    updateSessionRequestSchema,
+    sessionIdParamsSchema,
+    sessionResponseSchema,
+    sessionListResponseSchema,
+    sessionDeleteResponseSchema,
+    createInMemorySessionStore
+};

package/packages/server/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+export declare const cliModule: {
+    getBridgeServerCliHelpText: () => string;
+    parseBridgeServerCliArgs: (input: {
+        argv: string[];
+        env?: NodeJS.ProcessEnv;
+    }) => import("./run-bridge-server-cli.ts").BridgeServerCliCommand;
+    runBridgeServerCli: (input: import("./run-bridge-server-cli.ts").RunBridgeServerCliInput) => Promise<number>;
+};
+export type { BridgeServerCliCommand, RunBridgeServerCliInput } from "./run-bridge-server-cli.ts";

package/packages/server/dist/cli/index.js

@@ -0,0 +1,6 @@
+import { runBridgeServerCliModule } from "./run-bridge-server-cli.js";
+export const cliModule = {
+    getBridgeServerCliHelpText: runBridgeServerCliModule.getBridgeServerCliHelpText,
+    parseBridgeServerCliArgs: runBridgeServerCliModule.parseBridgeServerCliArgs,
+    runBridgeServerCli: runBridgeServerCliModule.runBridgeServerCli
+};

package/packages/server/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/server/dist/cli/main.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { cliModule } from "./index.js";
+const { runBridgeServerCli } = cliModule;
+const exitCode = await runBridgeServerCli({
+    argv: process.argv.slice(2)
+});
+if (exitCode !== 0) {
+    process.exitCode = exitCode;
+}

package/packages/server/dist/cli/run-bridge-server-cli.d.ts

@@ -0,0 +1,54 @@
+import type { LiveProviderExtractionCanaryInput } from "../bridge/index.ts";
+import type { BridgeApiClientFetch } from "../client/index.ts";
+import type { BridgeServerConfig } from "../config/index.ts";
+declare const runLiveProviderExtractionCanary: (input: LiveProviderExtractionCanaryInput) => Promise<import("../bridge/live-provider-extraction-canary.ts").LiveProviderExtractionCanaryResult>;
+declare const startBridgeApiServer: (options?: import("../http/create-bridge-api-server.ts").BridgeApiServerOptions) => Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;
+type BridgeServerCliCommand = {
+    kind: "help";
+} | {
+    kind: "serve";
+    config: BridgeServerConfig;
+} | {
+    kind: "clear-session-vault";
+    config: BridgeServerConfig;
+} | {
+    kind: "chat";
+    baseUrl: string;
+    model: string;
+    message: string;
+    system?: string;
+    stream: boolean;
+} | ({
+    kind: "live-canary";
+} & LiveProviderExtractionCanaryInput);
+type RunBridgeServerCliInput = {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+    stdout?: {
+        write(value: string): void;
+    };
+    stderr?: {
+        write(value: string): void;
+    };
+    stdin?: NodeJS.ReadStream;
+    startServer?: typeof startBridgeApiServer;
+    onServerStarted?: (server: Awaited<ReturnType<typeof startBridgeApiServer>>) => void;
+    runLiveCanary?: typeof runLiveProviderExtractionCanary;
+    fetchImpl?: BridgeApiClientFetch;
+    promptForVaultKey?: (context: {
+        keyPath: string;
+        stdin: NodeJS.ReadStream;
+    }) => Promise<string>;
+};
+declare function runBridgeServerCli(input: RunBridgeServerCliInput): Promise<number>;
+declare function parseBridgeServerCliArgs(input: {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+}): BridgeServerCliCommand;
+declare function getBridgeServerCliHelpText(): string;
+export declare const runBridgeServerCliModule: {
+    runBridgeServerCli: typeof runBridgeServerCli;
+    parseBridgeServerCliArgs: typeof parseBridgeServerCliArgs;
+    getBridgeServerCliHelpText: typeof getBridgeServerCliHelpText;
+};
+export type { BridgeServerCliCommand, RunBridgeServerCliInput };