@bestoneconsulting/sap-b1-bridge 1.0.0

package/dist/core.d.ts

@@ -0,0 +1,44 @@
+import { WebSocketServer } from "ws";
+import type { SAPB1BridgeOptions, SAPB1BridgeAPI, AgentInfo, QueryResult, ServiceLayerRequest, DiApiRequest, AgentCapabilities, CompanyInfo } from "./types";
+import { type IBridgeStorage } from "./storage";
+export declare class SAPB1Bridge implements SAPB1BridgeAPI {
+    private app;
+    private server;
+    private storage;
+    private appName;
+    private wsPath;
+    private apiPrefix;
+    private wss;
+    private connectedAgents;
+    private agentCaps;
+    private uiClients;
+    private pendingPings;
+    private pendingQueries;
+    constructor(options: SAPB1BridgeOptions, storageInstance?: IBridgeStorage);
+    private broadcastToUI;
+    private setupWebSocket;
+    private setupAPIRoutes;
+    executeQuery(agentId: string, sql: string): Promise<QueryResult>;
+    callServiceLayer(agentId: string, request: ServiceLayerRequest): Promise<QueryResult>;
+    callDiApi(agentId: string, request: DiApiRequest): Promise<QueryResult>;
+    private waitForResult;
+    getAgents(): Promise<AgentInfo[]>;
+    getAgent(id: string): Promise<AgentInfo | undefined>;
+    registerAgent(options: {
+        name: string;
+        serverName: string;
+        capabilities?: string[];
+        companyId?: string;
+    }): Promise<AgentInfo>;
+    deleteAgent(id: string): Promise<void>;
+    getCompanies(): Promise<CompanyInfo[]>;
+    createCompany(name: string, description?: string): Promise<CompanyInfo>;
+    deleteCompany(id: string): Promise<void>;
+    getAgentCapabilities(agentId: string): AgentCapabilities | null;
+    refreshAgentCapabilities(agentId: string): Promise<boolean>;
+    mountUI(mountPath?: string, staticDir?: string): void;
+    getConnectedAgentIds(): string[];
+    isAgentConnected(agentId: string): boolean;
+    getWebSocketServer(): WebSocketServer;
+    getStorage(): IBridgeStorage;
+}

package/dist/core.js

@@ -0,0 +1,587 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { z } from "zod";
+import path from "path";
+import express from "express";
+import { MemBridgeStorage } from "./storage";
+const capabilityStatusSchema = z.object({
+    enabled: z.boolean(),
+    available: z.boolean(),
+    reason: z.string().nullable(),
+});
+const agentCapabilitiesSchema = z.object({
+    sql: capabilityStatusSchema,
+    serviceLayer: capabilityStatusSchema,
+    diApi: capabilityStatusSchema,
+});
+const sapServiceLayerPayloadSchema = z.object({
+    method: z.enum(["GET", "POST", "PATCH", "PUT", "DELETE"]),
+    endpoint: z.string().min(1),
+    body: z.any().optional(),
+    queryParams: z.record(z.string()).optional(),
+});
+const sapDiApiPayloadSchema = z.object({
+    version: z.string().optional().default("1.0"),
+    operation: z.enum(["di_get", "di_add", "di_update", "di_action", "di_query"]),
+    object: z.string().min(1),
+    key: z.record(z.union([z.string(), z.number()])).optional(),
+    sapXml: z.string().optional(),
+    action: z.string().optional(),
+    options: z.object({
+        dryRun: z.boolean().optional(),
+        transaction: z.boolean().optional(),
+        returnXml: z.boolean().optional(),
+        allowDiQuery: z.boolean().optional(),
+    }).optional(),
+});
+const TARGET_TO_CAPABILITY_KEY = {
+    sql_server: "sql",
+    sap_service_layer: "serviceLayer",
+    sap_di_api: "diApi",
+};
+export class SAPB1Bridge {
+    constructor(options, storageInstance) {
+        this.connectedAgents = new Map();
+        this.agentCaps = new Map();
+        this.uiClients = new Set();
+        this.pendingPings = new Map();
+        this.pendingQueries = new Map();
+        this.app = options.app;
+        this.server = options.server;
+        this.storage = storageInstance || new MemBridgeStorage();
+        this.appName = options.appName || "SAP B1 Bridge";
+        this.wsPath = options.wsPath || "/ws";
+        this.apiPrefix = options.apiPrefix || "/api";
+        this.wss = new WebSocketServer({ server: this.server, path: this.wsPath });
+        this.setupWebSocket();
+        this.setupAPIRoutes();
+    }
+    broadcastToUI(message) {
+        const payload = JSON.stringify(message);
+        this.uiClients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        });
+    }
+    setupWebSocket() {
+        this.wss.on("connection", (ws, req) => {
+            let agentId = null;
+            let isUIClient = false;
+            const requestHost = req?.headers?.host;
+            ws.on("message", async (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    if (data.type === "ui_connect") {
+                        isUIClient = true;
+                        this.uiClients.add(ws);
+                        ws.send(JSON.stringify({ type: "ui_connected" }));
+                    }
+                    else if (data.type === "auth") {
+                        const agent = await this.storage.getAgentByApiKey(data.apiKey);
+                        if (agent) {
+                            agentId = agent.id;
+                            this.connectedAgents.set(agent.id, ws);
+                            await this.storage.updateAgentStatus(agent.id, "online", new Date());
+                            ws.send(JSON.stringify({
+                                type: "auth_success",
+                                agentId: agent.id,
+                                connectionName: agent.name,
+                                appName: this.appName,
+                                appUrl: process.env.REPLIT_DEV_DOMAIN
+                                    ? `https://${process.env.REPLIT_DEV_DOMAIN}`
+                                    : requestHost
+                                        ? `https://${requestHost}`
+                                        : undefined,
+                            }));
+                            this.broadcastToUI({
+                                type: "agent_status_update",
+                                agentId: agent.id,
+                                status: "online",
+                            });
+                            console.log(`[SAP B1 Bridge] Agent authenticated: ${agent.name}`);
+                        }
+                        else {
+                            ws.send(JSON.stringify({ type: "auth_failed" }));
+                            ws.close();
+                        }
+                    }
+                    else if (data.type === "heartbeat" && agentId) {
+                        await this.storage.updateAgentStatus(agentId, "online", new Date());
+                        ws.send(JSON.stringify({ type: "heartbeat_ack" }));
+                    }
+                    else if (data.type === "capabilities" && agentId) {
+                        try {
+                            const caps = agentCapabilitiesSchema.parse(data.capabilities);
+                            this.agentCaps.set(agentId, caps);
+                            this.broadcastToUI({
+                                type: "agent_capabilities_update",
+                                agentId,
+                                capabilities: caps,
+                            });
+                        }
+                        catch (e) {
+                            console.error(`[SAP B1 Bridge] Invalid capabilities from agent: ${agentId}`, e);
+                        }
+                    }
+                    else if (data.type === "query_result" && agentId) {
+                        if (!data.result) {
+                            data.result = data.results || data.rows || data.data || data.recordset;
+                        }
+                        const resultData = data.result || data.results;
+                        if (resultData && resultData.capabilities && typeof data.queryId === "string" && data.queryId.startsWith("cap-")) {
+                            try {
+                                const caps = agentCapabilitiesSchema.parse(resultData.capabilities);
+                                this.agentCaps.set(agentId, caps);
+                                this.broadcastToUI({
+                                    type: "agent_capabilities_update",
+                                    agentId,
+                                    capabilities: caps,
+                                });
+                            }
+                            catch (e) {
+                                console.error("[SAP B1 Bridge] Invalid capabilities in refresh response:", e);
+                            }
+                            return;
+                        }
+                        const { queryId, result, rowCount, executionTime, error } = data;
+                        const pending = this.pendingQueries.get(queryId);
+                        if (pending) {
+                            clearTimeout(pending.timer);
+                            this.pendingQueries.delete(queryId);
+                            if (error) {
+                                pending.resolve({ id: queryId, status: "error", error });
+                            }
+                            else {
+                                pending.resolve({ id: queryId, status: "completed", result, rowCount, executionTime });
+                            }
+                        }
+                        if (error) {
+                            await this.storage.updateQueryStatus(queryId, "error", {
+                                error,
+                                completedAt: new Date(),
+                            });
+                            this.broadcastToUI({ type: "query_completed", queryId, status: "error", error });
+                        }
+                        else {
+                            await this.storage.updateQueryStatus(queryId, "completed", {
+                                result,
+                                rowCount,
+                                executionTime,
+                                completedAt: new Date(),
+                            });
+                            this.broadcastToUI({ type: "query_completed", queryId, status: "completed", rowCount, executionTime });
+                        }
+                    }
+                    else if (data.type === "pong" && data.pingId) {
+                        const pending = this.pendingPings.get(data.pingId);
+                        if (pending) {
+                            clearTimeout(pending.timer);
+                            this.pendingPings.delete(data.pingId);
+                            pending.resolve(true);
+                        }
+                    }
+                    else if (data.type === "poll" && agentId) {
+                        const pendingQueries = await this.storage.getPendingQueriesForAgent(agentId);
+                        if (pendingQueries.length > 0) {
+                            const query = pendingQueries[0];
+                            await this.storage.updateQueryStatus(query.id, "executing", { executedAt: new Date() });
+                            if (query.targetType === "sql_server") {
+                                ws.send(JSON.stringify({
+                                    type: "execute_query",
+                                    queryId: query.id,
+                                    sqlQuery: query.sqlQuery,
+                                }));
+                            }
+                            else {
+                                const payload = query.requestPayload || {};
+                                if (payload.method && !payload.operation) {
+                                    payload.operation = payload.method;
+                                }
+                                ws.send(JSON.stringify({
+                                    type: "execute_request",
+                                    queryId: query.id,
+                                    targetType: query.targetType,
+                                    requestPayload: payload,
+                                }));
+                            }
+                            this.broadcastToUI({ type: "query_executing", queryId: query.id });
+                        }
+                        else {
+                            ws.send(JSON.stringify({ type: "no_queries" }));
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("[SAP B1 Bridge] WebSocket message error:", error);
+                }
+            });
+            ws.on("close", async () => {
+                if (agentId) {
+                    this.connectedAgents.delete(agentId);
+                    this.agentCaps.delete(agentId);
+                    await this.storage.updateAgentStatus(agentId, "offline", new Date());
+                    this.broadcastToUI({ type: "agent_status_update", agentId, status: "offline" });
+                    this.broadcastToUI({ type: "agent_capabilities_update", agentId, capabilities: null });
+                }
+                if (isUIClient) {
+                    this.uiClients.delete(ws);
+                }
+            });
+        });
+    }
+    setupAPIRoutes() {
+        const prefix = this.apiPrefix;
+        const app = this.app;
+        app.get(`${prefix}/config`, (_req, res) => {
+            res.json({ appName: this.appName });
+        });
+        app.post(`${prefix}/agents/:id/test`, async (req, res) => {
+            try {
+                const agent = await this.storage.getAgent(req.params.id);
+                if (!agent)
+                    return res.status(404).json({ error: "Agent not found" });
+                const ws = this.connectedAgents.get(agent.id);
+                if (!ws || ws.readyState !== WebSocket.OPEN) {
+                    return res.json({ success: false, message: "Agent is not connected" });
+                }
+                const pingId = `ping_${Date.now()}`;
+                const result = await new Promise((resolve) => {
+                    const timer = setTimeout(() => { this.pendingPings.delete(pingId); resolve(false); }, 5000);
+                    this.pendingPings.set(pingId, { resolve, timer });
+                    ws.send(JSON.stringify({ type: "ping", pingId }));
+                });
+                res.json(result
+                    ? { success: true, message: "Agent responded successfully" }
+                    : { success: false, message: "Agent did not respond within 5 seconds" });
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to test connection" });
+            }
+        });
+        app.get(`${prefix}/agents/capabilities`, async (_req, res) => {
+            try {
+                const result = {};
+                const allAgents = await this.storage.getAgents();
+                for (const agent of allAgents) {
+                    result[agent.id] = this.agentCaps.get(agent.id) || null;
+                }
+                res.json(result);
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch capabilities" });
+            }
+        });
+        app.post(`${prefix}/agents/:id/refresh-capabilities`, async (req, res) => {
+            try {
+                const agent = await this.storage.getAgent(req.params.id);
+                if (!agent)
+                    return res.status(404).json({ error: "Agent not found" });
+                const ws = this.connectedAgents.get(agent.id);
+                if (!ws || ws.readyState !== WebSocket.OPEN) {
+                    return res.json({ success: false, message: "Agent is not connected" });
+                }
+                const queryId = `cap-${Date.now()}`;
+                ws.send(JSON.stringify({
+                    type: "execute_request",
+                    queryId,
+                    targetType: "agent",
+                    requestPayload: { operation: "agent_capabilities" },
+                }));
+                res.json({ success: true, message: "Capability refresh requested" });
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to refresh capabilities" });
+            }
+        });
+        app.get(`${prefix}/agents`, async (_req, res) => {
+            try {
+                res.json(await this.storage.getAgents());
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch agents" });
+            }
+        });
+        app.post(`${prefix}/agents`, async (req, res) => {
+            try {
+                const agent = await this.storage.createAgent(req.body);
+                res.json(agent);
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to create agent" });
+            }
+        });
+        app.patch(`${prefix}/agents/:id`, async (req, res) => {
+            try {
+                await this.storage.updateAgent(req.params.id, req.body);
+                const agent = await this.storage.getAgent(req.params.id);
+                res.json(agent);
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to update agent" });
+            }
+        });
+        app.delete(`${prefix}/agents/:id`, async (req, res) => {
+            try {
+                await this.storage.deleteAgent(req.params.id);
+                res.json({ success: true });
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to delete agent" });
+            }
+        });
+        app.get(`${prefix}/companies`, async (_req, res) => {
+            try {
+                res.json(await this.storage.getCompanies());
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch companies" });
+            }
+        });
+        app.post(`${prefix}/companies`, async (req, res) => {
+            try {
+                const company = await this.storage.createCompany(req.body.name, req.body.description);
+                res.json(company);
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to create company" });
+            }
+        });
+        app.patch(`${prefix}/companies/:id`, async (req, res) => {
+            try {
+                await this.storage.updateCompany(req.params.id, req.body);
+                const company = await this.storage.getCompany(req.params.id);
+                res.json(company);
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to update company" });
+            }
+        });
+        app.delete(`${prefix}/companies/:id`, async (req, res) => {
+            try {
+                const allAgents = await this.storage.getAgents();
+                for (const agent of allAgents.filter((a) => a.companyId === req.params.id)) {
+                    await this.storage.updateAgent(agent.id, { companyId: null });
+                }
+                await this.storage.deleteCompany(req.params.id);
+                res.json({ success: true });
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to delete company" });
+            }
+        });
+        app.get(`${prefix}/queries`, async (_req, res) => {
+            try {
+                res.json(await this.storage.getQueries());
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch queries" });
+            }
+        });
+        app.get(`${prefix}/queries/recent`, async (_req, res) => {
+            try {
+                res.json(await this.storage.getRecentQueries(10));
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch recent queries" });
+            }
+        });
+        app.get(`${prefix}/queries/active`, async (_req, res) => {
+            try {
+                res.json(await this.storage.getActiveQuery());
+            }
+            catch (error) {
+                res.status(500).json({ error: "Failed to fetch active query" });
+            }
+        });
+        app.post(`${prefix}/queries`, async (req, res) => {
+            try {
+                const data = req.body;
+                if (data.agentId) {
+                    const caps = this.agentCaps.get(data.agentId);
+                    if (caps) {
+                        const capKey = TARGET_TO_CAPABILITY_KEY[data.targetType || "sql_server"];
+                        if (capKey) {
+                            const capStatus = caps[capKey];
+                            if (capStatus && !capStatus.available) {
+                                return res.status(400).json({
+                                    success: false,
+                                    code: "capability_unavailable",
+                                    capability: capKey,
+                                    reason: capStatus.reason || "Capability is not available on this agent",
+                                });
+                            }
+                        }
+                    }
+                }
+                if (data.targetType === "sap_service_layer") {
+                    if (!data.requestPayload)
+                        return res.status(400).json({ error: "requestPayload is required for SAP Service Layer requests" });
+                    sapServiceLayerPayloadSchema.parse(data.requestPayload);
+                    if (!data.sqlQuery || !data.sqlQuery.trim()) {
+                        const payload = data.requestPayload;
+                        data.sqlQuery = `${payload.method || "GET"} ${payload.endpoint || "/"}`;
+                    }
+                }
+                else if (data.targetType === "sap_di_api") {
+                    if (!data.requestPayload)
+                        return res.status(400).json({ error: "requestPayload is required for SAP DI API requests" });
+                    sapDiApiPayloadSchema.parse(data.requestPayload);
+                    if (!data.sqlQuery || !data.sqlQuery.trim()) {
+                        const payload = data.requestPayload;
+                        data.sqlQuery = `DI:${payload.operation || "unknown"} ${payload.object || "unknown"}`;
+                    }
+                }
+                const query = await this.storage.createQuery(data);
+                if (data.agentId && this.connectedAgents.has(data.agentId)) {
+                    const ws = this.connectedAgents.get(data.agentId);
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: "new_query", queryId: query.id }));
+                    }
+                }
+                this.broadcastToUI({ type: "query_submitted", queryId: query.id, agentId: data.agentId });
+                res.json(query);
+            }
+            catch (error) {
+                if (error instanceof z.ZodError) {
+                    res.status(400).json({ error: error.errors });
+                }
+                else {
+                    res.status(500).json({ error: "Failed to create query" });
+                }
+            }
+        });
+    }
+    async executeQuery(agentId, sql) {
+        const query = await this.storage.createQuery({ agentId, targetType: "sql_server", sqlQuery: sql });
+        const ws = this.connectedAgents.get(agentId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            await this.storage.updateQueryStatus(query.id, "error", { error: "Agent is not connected" });
+            return { id: query.id, status: "error", error: "Agent is not connected" };
+        }
+        await this.storage.updateQueryStatus(query.id, "executing", { executedAt: new Date() });
+        ws.send(JSON.stringify({ type: "execute_query", queryId: query.id, sqlQuery: sql }));
+        this.broadcastToUI({ type: "query_executing", queryId: query.id });
+        return this.waitForResult(query.id);
+    }
+    async callServiceLayer(agentId, request) {
+        sapServiceLayerPayloadSchema.parse(request);
+        const sqlQuery = `${request.method} ${request.endpoint}`;
+        const query = await this.storage.createQuery({
+            agentId,
+            targetType: "sap_service_layer",
+            sqlQuery,
+            requestPayload: request,
+        });
+        const ws = this.connectedAgents.get(agentId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            await this.storage.updateQueryStatus(query.id, "error", { error: "Agent is not connected" });
+            return { id: query.id, status: "error", error: "Agent is not connected" };
+        }
+        await this.storage.updateQueryStatus(query.id, "executing", { executedAt: new Date() });
+        const payload = { ...request };
+        if (payload.method && !payload.operation)
+            payload.operation = payload.method;
+        ws.send(JSON.stringify({
+            type: "execute_request",
+            queryId: query.id,
+            targetType: "sap_service_layer",
+            requestPayload: payload,
+        }));
+        this.broadcastToUI({ type: "query_executing", queryId: query.id });
+        return this.waitForResult(query.id);
+    }
+    async callDiApi(agentId, request) {
+        sapDiApiPayloadSchema.parse(request);
+        const sqlQuery = `DI:${request.operation} ${request.object}`;
+        const query = await this.storage.createQuery({
+            agentId,
+            targetType: "sap_di_api",
+            sqlQuery,
+            requestPayload: request,
+        });
+        const ws = this.connectedAgents.get(agentId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            await this.storage.updateQueryStatus(query.id, "error", { error: "Agent is not connected" });
+            return { id: query.id, status: "error", error: "Agent is not connected" };
+        }
+        await this.storage.updateQueryStatus(query.id, "executing", { executedAt: new Date() });
+        ws.send(JSON.stringify({
+            type: "execute_request",
+            queryId: query.id,
+            targetType: "sap_di_api",
+            requestPayload: request,
+        }));
+        this.broadcastToUI({ type: "query_executing", queryId: query.id });
+        return this.waitForResult(query.id);
+    }
+    waitForResult(queryId, timeoutMs = 300000) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pendingQueries.delete(queryId);
+                this.storage.updateQueryStatus(queryId, "error", { error: "Query timed out" });
+                resolve({ id: queryId, status: "error", error: "Query timed out" });
+            }, timeoutMs);
+            this.pendingQueries.set(queryId, { resolve, timer });
+        });
+    }
+    async getAgents() {
+        return this.storage.getAgents();
+    }
+    async getAgent(id) {
+        return this.storage.getAgent(id);
+    }
+    async registerAgent(options) {
+        return this.storage.createAgent(options);
+    }
+    async deleteAgent(id) {
+        return this.storage.deleteAgent(id);
+    }
+    async getCompanies() {
+        return this.storage.getCompanies();
+    }
+    async createCompany(name, description) {
+        return this.storage.createCompany(name, description);
+    }
+    async deleteCompany(id) {
+        return this.storage.deleteCompany(id);
+    }
+    getAgentCapabilities(agentId) {
+        return this.agentCaps.get(agentId) || null;
+    }
+    async refreshAgentCapabilities(agentId) {
+        const ws = this.connectedAgents.get(agentId);
+        if (!ws || ws.readyState !== WebSocket.OPEN)
+            return false;
+        const queryId = `cap-${Date.now()}`;
+        ws.send(JSON.stringify({
+            type: "execute_request",
+            queryId,
+            targetType: "agent",
+            requestPayload: { operation: "agent_capabilities" },
+        }));
+        return true;
+    }
+    mountUI(mountPath = "/bridge", staticDir) {
+        const clientDistPath = staticDir
+            ? path.resolve(staticDir)
+            : path.resolve(__dirname, "../dist/client");
+        this.app.use(mountPath, express.static(clientDistPath));
+        this.app.get(`${mountPath}/*`, (_req, res) => {
+            res.sendFile(path.join(clientDistPath, "index.html"));
+        });
+        console.log(`[SAP B1 Bridge] UI mounted at ${mountPath} (serving from ${clientDistPath})`);
+    }
+    getConnectedAgentIds() {
+        return Array.from(this.connectedAgents.keys());
+    }
+    isAgentConnected(agentId) {
+        const ws = this.connectedAgents.get(agentId);
+        return !!ws && ws.readyState === WebSocket.OPEN;
+    }
+    getWebSocketServer() {
+        return this.wss;
+    }
+    getStorage() {
+        return this.storage;
+    }
+}

package/dist/drizzle-storage.d.ts

@@ -0,0 +1,2 @@
+import type { IBridgeStorage } from "./storage";
+export declare function createDrizzleBridgeStorage(dbStorage: any): IBridgeStorage;

package/dist/drizzle-storage.js

@@ -0,0 +1,61 @@
+export function createDrizzleBridgeStorage(dbStorage) {
+    return {
+        async getCompanies() {
+            return dbStorage.getCompanies();
+        },
+        async getCompany(id) {
+            return dbStorage.getCompany(id);
+        },
+        async createCompany(name, description) {
+            return dbStorage.createCompany({ name, description });
+        },
+        async updateCompany(id, updates) {
+            return dbStorage.updateCompany(id, updates);
+        },
+        async deleteCompany(id) {
+            return dbStorage.deleteCompany(id);
+        },
+        async getAgents() {
+            return dbStorage.getAgents();
+        },
+        async getAgent(id) {
+            return dbStorage.getAgent(id);
+        },
+        async getAgentByApiKey(apiKey) {
+            return dbStorage.getAgentByApiKey(apiKey);
+        },
+        async createAgent(data) {
+            return dbStorage.createAgent(data);
+        },
+        async updateAgent(id, updates) {
+            return dbStorage.updateAgent(id, updates);
+        },
+        async updateAgentStatus(id, status, lastHeartbeat) {
+            return dbStorage.updateAgentStatus(id, status, lastHeartbeat);
+        },
+        async deleteAgent(id) {
+            return dbStorage.deleteAgent(id);
+        },
+        async getQueries() {
+            return dbStorage.getQueries();
+        },
+        async getQuery(id) {
+            return dbStorage.getQuery(id);
+        },
+        async getRecentQueries(limit) {
+            return dbStorage.getRecentQueries(limit);
+        },
+        async getPendingQueriesForAgent(agentId) {
+            return dbStorage.getPendingQueriesForAgent(agentId);
+        },
+        async getActiveQuery() {
+            return dbStorage.getActiveQuery();
+        },
+        async createQuery(data) {
+            return dbStorage.createQuery(data);
+        },
+        async updateQueryStatus(id, status, updates) {
+            return dbStorage.updateQueryStatus(id, status, updates);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { SAPB1BridgeOptions, SAPB1BridgeAPI } from "./types";
+import { type IBridgeStorage } from "./storage";
+export declare function createSAPB1Bridge(options: SAPB1BridgeOptions, storage?: IBridgeStorage): Promise<SAPB1BridgeAPI>;
+export { SAPB1Bridge } from "./core";
+export { MemBridgeStorage } from "./storage";
+export type { IBridgeStorage } from "./storage";
+export type { SAPB1BridgeOptions, SAPB1BridgeAPI, AgentInfo, QueryResult, ServiceLayerRequest, DiApiRequest, CapabilityStatus, AgentCapabilities, CompanyInfo, RegisterAgentOptions, } from "./types";

package/dist/index.js

@@ -0,0 +1,6 @@
+import { SAPB1Bridge } from "./core";
+export async function createSAPB1Bridge(options, storage) {
+    return new SAPB1Bridge(options, storage);
+}
+export { SAPB1Bridge } from "./core";
+export { MemBridgeStorage } from "./storage";

package/dist/storage.d.ts

@@ -0,0 +1,87 @@
+import type { AgentInfo, CompanyInfo } from "./types";
+export interface BridgeQuery {
+    id: string;
+    agentId: string | null;
+    targetType: string;
+    sqlQuery: string;
+    requestPayload: any;
+    status: string;
+    submittedAt: Date | null;
+    executedAt: Date | null;
+    completedAt: Date | null;
+    rowCount: number | null;
+    executionTime: number | null;
+    error: string | null;
+    result: any;
+}
+export interface IBridgeStorage {
+    getCompanies(): Promise<CompanyInfo[]>;
+    getCompany(id: string): Promise<CompanyInfo | undefined>;
+    createCompany(name: string, description?: string): Promise<CompanyInfo>;
+    updateCompany(id: string, updates: Partial<{
+        name: string;
+        description: string;
+    }>): Promise<void>;
+    deleteCompany(id: string): Promise<void>;
+    getAgents(): Promise<AgentInfo[]>;
+    getAgent(id: string): Promise<AgentInfo | undefined>;
+    getAgentByApiKey(apiKey: string): Promise<AgentInfo | undefined>;
+    createAgent(data: {
+        name: string;
+        serverName: string;
+        capabilities?: string[];
+        companyId?: string;
+    }): Promise<AgentInfo>;
+    updateAgent(id: string, updates: Partial<AgentInfo>): Promise<void>;
+    updateAgentStatus(id: string, status: string, lastHeartbeat: Date): Promise<void>;
+    deleteAgent(id: string): Promise<void>;
+    getQueries(): Promise<BridgeQuery[]>;
+    getQuery(id: string): Promise<BridgeQuery | undefined>;
+    getRecentQueries(limit: number): Promise<BridgeQuery[]>;
+    getPendingQueriesForAgent(agentId: string): Promise<BridgeQuery[]>;
+    getActiveQuery(): Promise<BridgeQuery | null>;
+    createQuery(data: {
+        agentId?: string;
+        targetType?: string;
+        sqlQuery: string;
+        requestPayload?: any;
+    }): Promise<BridgeQuery>;
+    updateQueryStatus(id: string, status: string, updates?: Partial<BridgeQuery>): Promise<void>;
+}
+export declare class MemBridgeStorage implements IBridgeStorage {
+    private companies;
+    private agents;
+    private queries;
+    getCompanies(): Promise<CompanyInfo[]>;
+    getCompany(id: string): Promise<CompanyInfo | undefined>;
+    createCompany(name: string, description?: string): Promise<CompanyInfo>;
+    updateCompany(id: string, updates: Partial<{
+        name: string;
+        description: string;
+    }>): Promise<void>;
+    deleteCompany(id: string): Promise<void>;
+    getAgents(): Promise<AgentInfo[]>;
+    getAgent(id: string): Promise<AgentInfo | undefined>;
+    getAgentByApiKey(apiKey: string): Promise<AgentInfo | undefined>;
+    createAgent(data: {
+        name: string;
+        serverName: string;
+        capabilities?: string[];
+        companyId?: string;
+    }): Promise<AgentInfo>;
+    updateAgent(id: string, updates: Partial<AgentInfo>): Promise<void>;
+    updateAgentStatus(id: string, status: string, lastHeartbeat: Date): Promise<void>;
+    deleteAgent(id: string): Promise<void>;
+    getQueries(): Promise<BridgeQuery[]>;
+    getQuery(id: string): Promise<BridgeQuery | undefined>;
+    getRecentQueries(limit: number): Promise<BridgeQuery[]>;
+    getPendingQueriesForAgent(agentId: string): Promise<BridgeQuery[]>;
+    getActiveQuery(): Promise<BridgeQuery | null>;
+    createQuery(data: {
+        agentId?: string;
+        targetType?: string;
+        sqlQuery: string;
+        requestPayload?: any;
+    }): Promise<BridgeQuery>;
+    updateQueryStatus(id: string, status: string, updates?: Partial<BridgeQuery>): Promise<void>;
+}

package/dist/storage.js

@@ -0,0 +1,123 @@
+import { randomUUID } from "crypto";
+export class MemBridgeStorage {
+    constructor() {
+        this.companies = new Map();
+        this.agents = new Map();
+        this.queries = new Map();
+    }
+    async getCompanies() {
+        return Array.from(this.companies.values());
+    }
+    async getCompany(id) {
+        return this.companies.get(id);
+    }
+    async createCompany(name, description) {
+        const id = randomUUID();
+        const company = { id, name, description: description || null, createdAt: new Date() };
+        this.companies.set(id, company);
+        return company;
+    }
+    async updateCompany(id, updates) {
+        const company = this.companies.get(id);
+        if (company)
+            Object.assign(company, updates);
+    }
+    async deleteCompany(id) {
+        this.companies.delete(id);
+    }
+    async getAgents() {
+        return Array.from(this.agents.values());
+    }
+    async getAgent(id) {
+        return this.agents.get(id);
+    }
+    async getAgentByApiKey(apiKey) {
+        return Array.from(this.agents.values()).find((a) => a.apiKey === apiKey);
+    }
+    async createAgent(data) {
+        const id = randomUUID();
+        const apiKey = `agent_${randomUUID().replace(/-/g, "")}`;
+        const agent = {
+            id,
+            name: data.name,
+            serverName: data.serverName,
+            status: "offline",
+            apiKey,
+            capabilities: data.capabilities || ["sql_server"],
+            companyId: data.companyId || null,
+            lastHeartbeat: null,
+            version: null,
+        };
+        this.agents.set(id, agent);
+        return agent;
+    }
+    async updateAgent(id, updates) {
+        const agent = this.agents.get(id);
+        if (agent)
+            Object.assign(agent, updates);
+    }
+    async updateAgentStatus(id, status, lastHeartbeat) {
+        const agent = this.agents.get(id);
+        if (agent) {
+            agent.status = status;
+            agent.lastHeartbeat = lastHeartbeat;
+        }
+    }
+    async deleteAgent(id) {
+        this.agents.delete(id);
+    }
+    async getQueries() {
+        return Array.from(this.queries.values()).sort((a, b) => {
+            const at = a.submittedAt ? a.submittedAt.getTime() : 0;
+            const bt = b.submittedAt ? b.submittedAt.getTime() : 0;
+            return bt - at;
+        });
+    }
+    async getQuery(id) {
+        return this.queries.get(id);
+    }
+    async getRecentQueries(limit) {
+        return (await this.getQueries()).slice(0, limit);
+    }
+    async getPendingQueriesForAgent(agentId) {
+        return Array.from(this.queries.values())
+            .filter((q) => q.agentId === agentId && q.status === "pending")
+            .sort((a, b) => {
+            const at = a.submittedAt ? a.submittedAt.getTime() : 0;
+            const bt = b.submittedAt ? b.submittedAt.getTime() : 0;
+            return at - bt;
+        });
+    }
+    async getActiveQuery() {
+        const sorted = await this.getQueries();
+        return sorted[0] || null;
+    }
+    async createQuery(data) {
+        const id = randomUUID();
+        const query = {
+            id,
+            agentId: data.agentId || null,
+            targetType: data.targetType || "sql_server",
+            sqlQuery: data.sqlQuery,
+            requestPayload: data.requestPayload || null,
+            status: "pending",
+            submittedAt: new Date(),
+            executedAt: null,
+            completedAt: null,
+            rowCount: null,
+            executionTime: null,
+            error: null,
+            result: null,
+        };
+        this.queries.set(id, query);
+        return query;
+    }
+    async updateQueryStatus(id, status, updates) {
+        const query = this.queries.get(id);
+        if (query) {
+            query.status = status;
+            if (updates)
+                Object.assign(query, updates);
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+import type { Server } from "http";
+import type { Express } from "express";
+export interface SAPB1BridgeOptions {
+    app: Express;
+    server: Server;
+    databaseUrl?: string;
+    appName?: string;
+    wsPath?: string;
+    apiPrefix?: string;
+}
+export interface AgentInfo {
+    id: string;
+    name: string;
+    serverName: string;
+    status: string;
+    apiKey: string;
+    capabilities: string[];
+    companyId: string | null;
+    lastHeartbeat: Date | null;
+    version: string | null;
+}
+export interface RegisterAgentOptions {
+    name: string;
+    serverName: string;
+    capabilities?: string[];
+    companyId?: string;
+}
+export interface QueryResult {
+    id: string;
+    status: string;
+    result?: any;
+    rowCount?: number | null;
+    executionTime?: number | null;
+    error?: string | null;
+}
+export interface ServiceLayerRequest {
+    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    endpoint: string;
+    body?: any;
+    queryParams?: Record<string, string>;
+}
+export interface DiApiRequest {
+    version?: string;
+    operation: "di_get" | "di_add" | "di_update" | "di_action" | "di_query";
+    object: string;
+    key?: Record<string, string | number>;
+    sapXml?: string;
+    action?: string;
+    options?: {
+        dryRun?: boolean;
+        transaction?: boolean;
+        returnXml?: boolean;
+        allowDiQuery?: boolean;
+    };
+}
+export interface CapabilityStatus {
+    enabled: boolean;
+    available: boolean;
+    reason: string | null;
+}
+export interface AgentCapabilities {
+    sql: CapabilityStatus;
+    serviceLayer: CapabilityStatus;
+    diApi: CapabilityStatus;
+}
+export interface CompanyInfo {
+    id: string;
+    name: string;
+    description: string | null;
+    createdAt: Date | null;
+}
+export interface SAPB1BridgeAPI {
+    executeQuery(agentId: string, sql: string): Promise<QueryResult>;
+    callServiceLayer(agentId: string, request: ServiceLayerRequest): Promise<QueryResult>;
+    callDiApi(agentId: string, request: DiApiRequest): Promise<QueryResult>;
+    getAgents(): Promise<AgentInfo[]>;
+    getAgent(id: string): Promise<AgentInfo | undefined>;
+    registerAgent(options: RegisterAgentOptions): Promise<AgentInfo>;
+    deleteAgent(id: string): Promise<void>;
+    getCompanies(): Promise<CompanyInfo[]>;
+    createCompany(name: string, description?: string): Promise<CompanyInfo>;
+    deleteCompany(id: string): Promise<void>;
+    getAgentCapabilities(agentId: string): AgentCapabilities | null;
+    refreshAgentCapabilities(agentId: string): Promise<boolean>;
+    mountUI(path?: string, staticDir?: string): void;
+    getConnectedAgentIds(): string[];
+    isAgentConnected(agentId: string): boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bestoneconsulting/sap-b1-bridge",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "SAP Business One & SQL Server bridge for secure database and ERP access behind firewalls via WebSocket agents",
+  "author": "Best One Consulting <https://www.bestoneconsulting.com/>",
+  "homepage": "https://www.bestoneconsulting.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bestoneconsulting/sap-b1-bridge"
+  },
+  "keywords": ["sap", "business-one", "b1", "sql-server", "bridge", "websocket", "agent", "erp", "di-api", "service-layer"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "express": ">=4.0.0",
+    "ws": ">=8.0.0",
+    "zod": ">=3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p ../tsconfig.bridge.json",
+    "prepublishOnly": "npm run build"
+  }
+}