@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/bridge/state/file-bridge-state-store.js

@@ -0,0 +1,164 @@
+import crypto from "node:crypto";
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+class FileBridgeStateStore {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+    }
+    async loadProviderSession(providerId) {
+        try {
+            const raw = await readFile(this.getProviderSessionPath(providerId), "utf8");
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async loadBinding(providerId, sessionId) {
+        try {
+            const raw = await readFile(this.getConversationPath(providerId, sessionId), "utf8");
+            const parsed = JSON.parse(raw);
+            return {
+                conversationId: parsed.conversationId,
+                parentId: parsed.parentId,
+                runtimePlannerPrimed: parsed.runtimePlannerPrimed
+            };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async saveBinding(providerId, sessionId, binding) {
+        const stored = {
+            providerId,
+            sessionId,
+            conversationId: binding.conversationId,
+            parentId: binding.parentId,
+            runtimePlannerPrimed: binding.runtimePlannerPrimed,
+            updatedAt: new Date().toISOString()
+        };
+        await writeSecureJson(this.getConversationPath(providerId, sessionId), stored);
+    }
+    async clearBinding(providerId, sessionId) {
+        try {
+            await unlink(this.getConversationPath(providerId, sessionId));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+    async loadSessionHistory(sessionId) {
+        const stored = await this.readStoredSessionHistory(sessionId);
+        return (stored?.turns.map((turn) => ({
+            userMessage: turn.userMessage,
+            assistantMessage: turn.assistantMessage,
+            assistantMode: turn.assistantMode
+        })) ?? []);
+    }
+    async appendSessionTurn(sessionId, turn) {
+        const stored = (await this.readStoredSessionHistory(sessionId)) ?? {
+            sessionId,
+            turns: []
+        };
+        stored.turns.push({
+            ...turn,
+            recordedAt: new Date().toISOString()
+        });
+        await writeSecureJson(this.getSessionHistoryPath(sessionId), stored);
+    }
+    async loadChatCompletionSession(providerId, modelKey, lookupKey) {
+        try {
+            const raw = await readFile(this.getChatCompletionContinuationPath(providerId, modelKey, lookupKey), "utf8");
+            const parsed = JSON.parse(raw);
+            return typeof parsed.sessionId === "string" && parsed.sessionId ? parsed.sessionId : null;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async loadSharedChatCompletionSession(lookupKey) {
+        try {
+            const raw = await readFile(this.getSharedChatCompletionContinuationPath(lookupKey), "utf8");
+            const parsed = JSON.parse(raw);
+            return typeof parsed.sessionId === "string" && parsed.sessionId ? parsed.sessionId : null;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async saveChatCompletionSession(providerId, modelKey, lookupKey, sessionId) {
+        const stored = {
+            providerId,
+            modelKey,
+            lookupKey,
+            sessionId,
+            updatedAt: new Date().toISOString()
+        };
+        await writeSecureJson(this.getChatCompletionContinuationPath(providerId, modelKey, lookupKey), stored);
+    }
+    async saveSharedChatCompletionSession(lookupKey, sessionId, metadata) {
+        const stored = {
+            lookupKey,
+            sessionId,
+            providerId: metadata?.providerId,
+            modelKey: metadata?.modelKey,
+            updatedAt: new Date().toISOString()
+        };
+        await writeSecureJson(this.getSharedChatCompletionContinuationPath(lookupKey), stored);
+    }
+    async readStoredSessionHistory(sessionId) {
+        try {
+            const raw = await readFile(this.getSessionHistoryPath(sessionId), "utf8");
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    getProviderSessionPath(providerId) {
+        return path.join(this.rootDir, "sessions", `${providerId}.json`);
+    }
+    getConversationPath(providerId, sessionId) {
+        const digest = crypto.createHash("sha256").update(sessionId).digest("hex");
+        return path.join(this.rootDir, "conversations", `${providerId}-${digest}.json`);
+    }
+    getSessionHistoryPath(sessionId) {
+        const digest = crypto.createHash("sha256").update(sessionId).digest("hex");
+        return path.join(this.rootDir, "bridge-sessions", `${digest}.json`);
+    }
+    getChatCompletionContinuationPath(providerId, modelKey, lookupKey) {
+        const digest = crypto.createHash("sha256").update(`${modelKey}:${lookupKey}`).digest("hex");
+        return path.join(this.rootDir, "chat-completion-continuations", `${providerId}-${digest}.json`);
+    }
+    getSharedChatCompletionContinuationPath(lookupKey) {
+        const digest = crypto.createHash("sha256").update(lookupKey).digest("hex");
+        return path.join(this.rootDir, "chat-completion-continuations", `shared-${digest}.json`);
+    }
+}
+async function writeSecureJson(targetPath, value) {
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await chmod(targetPath, 0o600);
+}
+export const fileBridgeStateStoreModule = {
+    FileBridgeStateStore
+};

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

@@ -0,0 +1,23 @@
+import type { SessionPackageStore } from "./session-package-store.ts";
+type LocalSessionPackageStoreOptions = {
+    vaultPath: string;
+    keyPath: string;
+    keyMaterial?: string | null;
+    now?: () => string;
+    testHooks?: {
+        afterTempWrite?: (targetPath: string, tempPath: string) => void;
+    };
+};
+declare class SessionPackageVaultError extends Error {
+    constructor(message: string);
+}
+declare function clearLocalSessionVault(input: {
+    vaultPath: string;
+}): void;
+declare function createLocalSessionPackageStore(options: LocalSessionPackageStoreOptions): SessionPackageStore;
+export declare const localSessionPackageStoreModule: {
+    SessionPackageVaultError: typeof SessionPackageVaultError;
+    clearLocalSessionVault: typeof clearLocalSessionVault;
+    createLocalSessionPackageStore: typeof createLocalSessionPackageStore;
+};
+export type { LocalSessionPackageStoreOptions, SessionPackageVaultError };