@olane/o-storage 0.7.5 → 0.7.7

package/dist/src/index.d.ts

@@ -2,4 +2,8 @@ export * from './storage.tool.js';
 export * from './providers/index.js';
 export * from './interfaces/index.js';
 export * from './placeholder.tool.js';
+export * from './os-config-storage.tool.js';
+export * from './methods/placeholder-storage.methods.js';
+export * from './methods/storage.methods.js';
+export * from './methods/os-config.methods.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC;AACzD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/dist/src/index.js

@@ -2,3 +2,7 @@ export * from './storage.tool.js';
 export * from './providers/index.js';
 export * from './interfaces/index.js';
 export * from './placeholder.tool.js';
+export * from './os-config-storage.tool.js';
+export * from './methods/placeholder-storage.methods.js';
+export * from './methods/storage.methods.js';
+export * from './methods/os-config.methods.js';

package/dist/src/methods/os-config.methods.d.ts

@@ -0,0 +1,3 @@
+import { oMethod } from '@olane/o-protocol';
+export declare const OS_CONFIG_METHODS: Record<string, oMethod>;
+//# sourceMappingURL=os-config.methods.d.ts.map

package/dist/src/methods/os-config.methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os-config.methods.d.ts","sourceRoot":"","sources":["../../../src/methods/os-config.methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAmJrD,CAAC"}

package/dist/src/methods/os-config.methods.js

@@ -0,0 +1,148 @@
+export const OS_CONFIG_METHODS = {
+    save_config: {
+        name: 'save_config',
+        description: 'Save OS instance configuration to storage',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+            {
+                name: 'config',
+                type: 'object',
+                value: 'object',
+                description: 'OS instance configuration object',
+                required: true,
+            },
+        ],
+    },
+    load_config: {
+        name: 'load_config',
+        description: 'Load OS instance configuration from storage',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+        ],
+    },
+    list_configs: {
+        name: 'list_configs',
+        description: 'List all OS instance configurations',
+        dependencies: [],
+        parameters: [],
+    },
+    delete_config: {
+        name: 'delete_config',
+        description: 'Delete OS instance configuration',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance to delete',
+                required: true,
+            },
+        ],
+    },
+    add_lane_to_config: {
+        name: 'add_lane_to_config',
+        description: 'Add a lane CID to the OS instance startup configuration',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+            {
+                name: 'cid',
+                type: 'string',
+                value: 'string',
+                description: 'Content ID of the lane to add',
+                required: true,
+            },
+        ],
+    },
+    remove_lane_from_config: {
+        name: 'remove_lane_from_config',
+        description: 'Remove a lane CID from the OS instance startup configuration',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+            {
+                name: 'cid',
+                type: 'string',
+                value: 'string',
+                description: 'Content ID of the lane to remove',
+                required: true,
+            },
+        ],
+    },
+    get_lanes: {
+        name: 'get_lanes',
+        description: 'Get all lane CIDs for an OS instance',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+        ],
+    },
+    update_metadata: {
+        name: 'update_metadata',
+        description: 'Update metadata for an OS instance (e.g., last indexed time)',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+            {
+                name: 'metadata',
+                type: 'object',
+                value: 'object',
+                description: 'Metadata object to merge into the config',
+                required: true,
+            },
+        ],
+    },
+    get_metadata: {
+        name: 'get_metadata',
+        description: 'Get metadata for an OS instance',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'osName',
+                type: 'string',
+                value: 'string',
+                description: 'Name of the OS instance',
+                required: true,
+            },
+        ],
+    },
+};

package/dist/src/os-config-storage.tool.d.ts

@@ -0,0 +1,76 @@
+import { ToolResult } from '@olane/o-tool';
+import { oRequest } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeToolConfig } from '@olane/o-node';
+export interface OSConfigStorageConfig extends oNodeToolConfig {
+    /**
+     * Storage backend to use for OS configuration.
+     * - 'disk': Local filesystem (default for local OS)
+     * - 'memory': In-memory storage (volatile)
+     * - string: Any other storage backend address
+     */
+    storageBackend?: 'disk' | 'memory' | string;
+}
+/**
+ * OS Configuration Storage Tool
+ *
+ * Provides a unified interface for OS instance configuration management.
+ * Delegates to appropriate storage providers based on environment configuration.
+ *
+ * Storage Backends:
+ * - 'disk': Local filesystem storage (default for local OS deployments)
+ * - 'memory': In-memory storage (volatile, for testing)
+ * - string: Any other storage backend address
+ *
+ * Address: o://os-config
+ */
+export declare class OSConfigStorageTool extends oLaneTool {
+    private storageBackend;
+    private configKeyPrefix;
+    constructor(config: OSConfigStorageConfig);
+    /**
+     * Get the storage address for the configured backend
+     */
+    private getStorageAddress;
+    /**
+     * Generate storage key for OS config
+     */
+    private getConfigKey;
+    /**
+     * Save OS instance configuration
+     */
+    _tool_save_config(request: oRequest): Promise<ToolResult>;
+    /**
+     * Load OS instance configuration
+     */
+    _tool_load_config(request: oRequest): Promise<ToolResult>;
+    /**
+     * List all OS instance configurations
+     */
+    _tool_list_configs(request: oRequest): Promise<ToolResult>;
+    /**
+     * Delete OS instance configuration
+     */
+    _tool_delete_config(request: oRequest): Promise<ToolResult>;
+    /**
+     * Add a lane CID to OS instance startup configuration
+     */
+    _tool_add_lane_to_config(request: oRequest): Promise<ToolResult>;
+    /**
+     * Remove a lane CID from OS instance startup configuration
+     */
+    _tool_remove_lane_from_config(request: oRequest): Promise<ToolResult>;
+    /**
+     * Get all lane CIDs for an OS instance
+     */
+    _tool_get_lanes(request: oRequest): Promise<ToolResult>;
+    /**
+     * Update metadata for an OS instance
+     */
+    _tool_update_metadata(request: oRequest): Promise<ToolResult>;
+    /**
+     * Get metadata for an OS instance
+     */
+    _tool_get_metadata(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=os-config-storage.tool.d.ts.map

package/dist/src/os-config-storage.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os-config-storage.tool.d.ts","sourceRoot":"","sources":["../../src/os-config-storage.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGhD,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC5D;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC7C;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,eAAe,CAAgB;gBAE3B,MAAM,EAAE,qBAAqB;IAiBzC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA2B/D;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAgC/D;;OAEG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBhE;;OAEG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA0BjE;;OAEG;IACG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA8DtE;;OAEG;IACG,6BAA6B,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAmE3E;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAkC7D;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAmDnE;;OAEG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAoBjE"}

package/dist/src/os-config-storage.tool.js

@@ -0,0 +1,351 @@
+import { oAddress, oRequest } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { OS_CONFIG_METHODS } from './methods/os-config.methods.js';
+/**
+ * OS Configuration Storage Tool
+ *
+ * Provides a unified interface for OS instance configuration management.
+ * Delegates to appropriate storage providers based on environment configuration.
+ *
+ * Storage Backends:
+ * - 'disk': Local filesystem storage (default for local OS deployments)
+ * - 'memory': In-memory storage (volatile, for testing)
+ * - string: Any other storage backend address
+ *
+ * Address: o://os-config
+ */
+export class OSConfigStorageTool extends oLaneTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://os-config'),
+            description: 'OS instance configuration storage management',
+            methods: OS_CONFIG_METHODS,
+        });
+        this.configKeyPrefix = 'os-config:';
+        // Determine storage backend from config or environment
+        this.storageBackend =
+            config.storageBackend ||
+                process.env.OS_CONFIG_STORAGE ||
+                'disk';
+        this.logger.info(`OS Config Storage using backend: ${this.storageBackend}`);
+    }
+    /**
+     * Get the storage address for the configured backend
+     */
+    getStorageAddress() {
+        return new oAddress(`o://${this.storageBackend}`);
+    }
+    /**
+     * Generate storage key for OS config
+     */
+    getConfigKey(osName) {
+        return `${this.configKeyPrefix}${osName}`;
+    }
+    /**
+     * Save OS instance configuration
+     */
+    async _tool_save_config(request) {
+        const { osName, config } = request.params;
+        try {
+            this.logger.debug(`Saving config for OS instance: ${osName}`);
+            await this.use(this.getStorageAddress(), {
+                method: 'put',
+                params: {
+                    key: this.getConfigKey(osName),
+                    value: JSON.stringify(config),
+                },
+            });
+            return {
+                success: true,
+                message: `OS configuration saved for: ${osName}`,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to save OS config:', error);
+            return {
+                success: false,
+                error: `Failed to save configuration: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Load OS instance configuration
+     */
+    async _tool_load_config(request) {
+        const { osName } = request.params;
+        try {
+            this.logger.debug(`Loading config for OS instance: ${osName}`);
+            const result = await this.use(this.getStorageAddress(), {
+                method: 'get',
+                params: {
+                    key: this.getConfigKey(osName),
+                },
+            });
+            const configData = result.result.data;
+            if (!configData || !configData.value) {
+                return {
+                    success: false,
+                    error: `No configuration found for OS instance: ${osName}`,
+                };
+            }
+            return JSON.parse(configData.value);
+        }
+        catch (error) {
+            this.logger.error('Failed to load OS config:', error);
+            return {
+                success: false,
+                error: `Failed to load configuration: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * List all OS instance configurations
+     */
+    async _tool_list_configs(request) {
+        try {
+            this.logger.debug('Listing all OS configurations');
+            // For disk backend, we need to list directory contents
+            // For other backends, we'd need to implement a list operation
+            // This is a simplified implementation
+            return {
+                success: true,
+                message: 'List operation not fully implemented yet - use ConfigManager.listOSInstances() for now',
+                data: [],
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to list OS configs:', error);
+            return {
+                success: false,
+                error: `Failed to list configurations: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Delete OS instance configuration
+     */
+    async _tool_delete_config(request) {
+        const { osName } = request.params;
+        try {
+            this.logger.debug(`Deleting config for OS instance: ${osName}`);
+            await this.use(this.getStorageAddress(), {
+                method: 'delete',
+                params: {
+                    key: this.getConfigKey(osName),
+                },
+            });
+            return {
+                success: true,
+                message: `OS configuration deleted for: ${osName}`,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to delete OS config:', error);
+            return {
+                success: false,
+                error: `Failed to delete configuration: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Add a lane CID to OS instance startup configuration
+     */
+    async _tool_add_lane_to_config(request) {
+        const { osName, cid } = request.params;
+        try {
+            this.logger.debug(`Adding lane ${cid} to config for OS instance: ${osName}`);
+            // Load current config
+            const loadResult = await this._tool_load_config(new oRequest({
+                id: request.id,
+                method: request.method,
+                params: {
+                    _connectionId: request.params._connectionId,
+                    _requestMethod: request.params._requestMethod,
+                    osName,
+                },
+            }));
+            const config = loadResult;
+            // Initialize lanes array if it doesn't exist
+            if (!config.oNetworkConfig) {
+                config.oNetworkConfig = {};
+            }
+            if (!config.oNetworkConfig.lanes) {
+                config.oNetworkConfig.lanes = [];
+            }
+            // Add CID if not already present
+            if (!config.oNetworkConfig.lanes.includes(cid)) {
+                config.oNetworkConfig.lanes.push(cid);
+                // Save updated config
+                await this._tool_save_config(new oRequest({
+                    id: request.id,
+                    method: request.method,
+                    params: {
+                        _connectionId: request.params._connectionId,
+                        _requestMethod: request.params._requestMethod,
+                        osName,
+                        config,
+                    },
+                }));
+            }
+            return {
+                success: true,
+                message: `Lane ${cid} added to OS configuration: ${osName}`,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to add lane to OS config:', error);
+            return {
+                success: false,
+                error: `Failed to add lane: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Remove a lane CID from OS instance startup configuration
+     */
+    async _tool_remove_lane_from_config(request) {
+        const { osName, cid } = request.params;
+        try {
+            this.logger.debug(`Removing lane ${cid} from config for OS instance: ${osName}`);
+            // Load current config
+            const loadResult = await this._tool_load_config(new oRequest({
+                id: request.id,
+                method: request.method,
+                params: {
+                    _connectionId: request.params._connectionId,
+                    _requestMethod: request.params._requestMethod,
+                    osName,
+                },
+            }));
+            if (!loadResult.success) {
+                return loadResult;
+            }
+            const config = loadResult.data;
+            if (!config.oNetworkConfig?.lanes) {
+                return {
+                    success: true,
+                    message: 'No lanes found in configuration',
+                };
+            }
+            // Remove CID if present
+            const index = config.oNetworkConfig.lanes.indexOf(cid);
+            if (index > -1) {
+                config.oNetworkConfig.lanes.splice(index, 1);
+                // Save updated config
+                await this._tool_save_config(new oRequest({
+                    id: request.id,
+                    method: request.method,
+                    params: {
+                        _connectionId: request.params._connectionId,
+                        _requestMethod: request.params._requestMethod,
+                        osName,
+                        config,
+                    },
+                }));
+            }
+            return {
+                success: true,
+                message: `Lane ${cid} removed from OS configuration: ${osName}`,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to remove lane from OS config:', error);
+            return {
+                success: false,
+                error: `Failed to remove lane: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Get all lane CIDs for an OS instance
+     */
+    async _tool_get_lanes(request) {
+        const { osName } = request.params;
+        try {
+            this.logger.debug(`Getting lanes for OS instance: ${osName}`);
+            // Load current config
+            const loadResult = await this._tool_load_config(new oRequest({
+                id: request.id,
+                method: request.method,
+                params: {
+                    _connectionId: request.params._connectionId,
+                    _requestMethod: request.params._requestMethod,
+                    osName,
+                },
+            }));
+            const config = loadResult;
+            const lanes = config.oNetworkConfig?.lanes || [];
+            return {
+                lanes,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get lanes from OS config:', error);
+            return {
+                success: false,
+                error: `Failed to get lanes: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Update metadata for an OS instance
+     */
+    async _tool_update_metadata(request) {
+        const { osName, metadata } = request.params;
+        this.logger.debug(`Updating metadata for OS instance: ${osName}`);
+        // Load current config (or create new one if doesn't exist)
+        const loadResult = await this._tool_load_config(new oRequest({
+            id: request.id,
+            method: request.method,
+            params: {
+                _connectionId: request.params._connectionId,
+                _requestMethod: request.params._requestMethod,
+                osName,
+            },
+        }));
+        let config = {};
+        if (loadResult.success) {
+            config = loadResult.data;
+        }
+        // Initialize metadata object if it doesn't exist
+        if (!config.metadata) {
+            config.metadata = {};
+        }
+        // Merge new metadata with existing metadata
+        config.metadata = {
+            ...config.metadata,
+            ...metadata,
+        };
+        // Save updated config
+        await this._tool_save_config(new oRequest({
+            id: request.id,
+            method: request.method,
+            params: {
+                _connectionId: request.params._connectionId,
+                _requestMethod: request.params._requestMethod,
+                osName,
+                config,
+            },
+        }));
+        return config.metadata;
+    }
+    /**
+     * Get metadata for an OS instance
+     */
+    async _tool_get_metadata(request) {
+        const { osName } = request.params;
+        this.logger.debug(`Getting metadata for OS instance: ${osName}`);
+        // Load current config
+        const config = await this._tool_load_config(new oRequest({
+            id: request.id,
+            method: request.method,
+            params: {
+                _connectionId: request.params._connectionId,
+                _requestMethod: request.params._requestMethod,
+                osName,
+            },
+        }));
+        return config.metadata || {};
+    }
+}

package/dist/src/storage.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.tool.d.ts","sourceRoot":"","sources":["../../src/storage.tool.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,qBAAa,WAAY,SAAQ,SAAS;gBAC5B,MAAM,EAAE,eAAe;IAS7B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAqClC"}
+{"version":3,"file":"storage.tool.d.ts","sourceRoot":"","sources":["../../src/storage.tool.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,qBAAa,WAAY,SAAQ,SAAS;gBAC5B,MAAM,EAAE,eAAe;IAS7B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAoDlC"}

package/dist/src/storage.tool.js

@@ -3,6 +3,7 @@ import { DiskStorageProvider } from './providers/disk-storage-provider.tool.js';
 import { MemoryStorageProvider } from './providers/memory-storage-provider.tool.js';
 import { SecureStorageProvider } from './providers/secure-storage-provider.tool.js';
 import { PlaceholderTool } from './placeholder.tool.js';
+import { OSConfigStorageTool } from './os-config-storage.tool.js';
 import { oLaneTool } from '@olane/o-lane';
 export class StorageTool extends oLaneTool {
     constructor(config) {
@@ -45,5 +46,18 @@ export class StorageTool extends oLaneTool {
         });
         await node.start();
         this.addChildNode(node);
+        // Add OS Config Storage Tool for managing OS instance configurations
+        // Note: This tool provides a unified interface that delegates to storage providers.
+        // For Lambda/cloud deployments, use 'supabase' backend (configured in o-network-lambda).
+        // For local deployments, use 'disk' or 'memory' backend.
+        node = new OSConfigStorageTool({
+            name: 'os-config',
+            parent: this.address,
+            leader: this.leader,
+            storageBackend: process.env.OS_CONFIG_STORAGE ||
+                'disk',
+        });
+        await node.start();
+        this.addChildNode(node);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-storage",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -56,12 +56,12 @@
     "typescript": "5.4.5"
   },
   "peerDependencies": {
-    "@olane/o-config": "^0.7.4",
-    "@olane/o-core": "^0.7.4",
-    "@olane/o-lane": "^0.7.4",
-    "@olane/o-node": "^0.7.4",
-    "@olane/o-protocol": "^0.7.4",
-    "@olane/o-tool": "^0.7.4"
+    "@olane/o-config": "^0.7.6",
+    "@olane/o-core": "^0.7.6",
+    "@olane/o-lane": "^0.7.6",
+    "@olane/o-node": "^0.7.6",
+    "@olane/o-protocol": "^0.7.6",
+    "@olane/o-tool": "^0.7.6"
   },
   "dependencies": {
     "debug": "^4.4.1",