opensecureconf-client 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alessandro Pioli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+# OpenSecureConf JavaScript/TypeScript Client
+
+JavaScript/TypeScript client library for [OpenSecureConf](https://github.com/yourusername/OpenSecureConf) - A secure, encrypted configuration management system with REST API.
+
+[![npm version](https://badge.fury.io/js/opensecureconf-client.svg)](https://www.npmjs.com/package/opensecureconf-client)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔐 **Encrypted Configuration Management** - Create, read, update, and delete encrypted configurations
+- 🌐 **REST API Client** - Full-featured client for OpenSecureConf REST API
+- 📦 **TypeScript Support** - Written in TypeScript with full type definitions
+- 🔄 **Cluster Support** - Works with both REPLICA and FEDERATED cluster modes
+- ⚡ **Async/Await** - Modern promise-based API
+- 🛡️ **Error Handling** - Comprehensive error handling with custom error types
+- ⏱️ **Timeout Control** - Configurable request timeouts
+- 🧪 **Well Tested** - Comprehensive test suite with Jest
+
+## Installation
+
+```bash
+npm install opensecureconf-client
+```
+
+## Quick Start
+
+### JavaScript (CommonJS)
+
+```javascript
+const { OpenSecureConfClient } = require('opensecureconf-client');
+
+const client = new OpenSecureConfClient({
+  baseUrl: 'http://localhost:9000',
+  userKey: 'my-secure-encryption-key',
+  apiKey: 'your-api-key', // Optional
+});
+
+// Create a configuration
+await client.create('my-config', { setting: 'value' }, 'category');
+
+// Read a configuration
+const config = await client.read('my-config');
+console.log(config.value); // { setting: 'value' }
+```
+
+### TypeScript (ES Modules)
+
+```typescript
+import OpenSecureConfClient from 'opensecureconf-client';
+
+const client = new OpenSecureConfClient({
+  baseUrl: 'http://localhost:9000',
+  userKey: 'my-secure-encryption-key',
+});
+
+const config = await client.read('my-config');
+```
+
+## API Reference
+
+### Methods
+
+- `create(key, value, category?)` - Create new configuration
+- `read(key)` - Read configuration by key
+- `update(key, value, category?)` - Update configuration
+- `delete(key)` - Delete configuration
+- `list(category?)` - List all configurations
+- `getClusterStatus()` - Get cluster status
+- `healthCheck()` - Perform health check
+- `getMetrics()` - Get Prometheus metrics
+- `getInfo()` - Get API information
+
+## Error Handling
+
+```typescript
+import { OpenSecureConfError } from 'opensecureconf-client';
+
+try {
+  await client.read('non-existent-key');
+} catch (error) {
+  if (error instanceof OpenSecureConfError) {
+    console.error(`Error ${error.statusCode}: ${error.message}`);
+  }
+}
+```
+
+## Development
+
+```bash
+npm install          # Install dependencies
+npm run build        # Build for production
+npm test             # Run tests
+npm run lint         # Lint code
+```
+
+## License
+
+MIT © OpenSecureConf Contributors
+"
+tests/client.test.ts,"import { OpenSecureConfClient, OpenSecureConfError } from '../src/index';
+
+describe('OpenSecureConfClient', () => {
+  let client: OpenSecureConfClient;
+
+  beforeEach(() => {
+    client = new OpenSecureConfClient({
+      baseUrl: 'http://localhost:9000',
+      userKey: 'test-user-key-12345',
+      apiKey: 'your-super-secret-api-key-here',
+    });
+  });
+
+  describe('constructor', () => {
+    it('should create client with valid options', () => {
+      expect(client).toBeInstanceOf(OpenSecureConfClient);
+    });
+
+    it('should throw error if userKey is too short', () => {
+      expect(() => {
+        new OpenSecureConfClient({
+          baseUrl: 'http://localhost:9000',
+          userKey: 'short',
+        });
+      }).toThrow('userKey must be at least 8 characters long');
+    });
+  });
+
+  describe('CRUD operations', () => {
+    const testKey = 'test-config-key';
+    const testValue = { setting: 'value', number: 42 };
+
+    it('should create a configuration', async () => {
+      const result = await client.create(testKey, testValue, 'test-category');
+      expect(result).toHaveProperty('key', testKey);
+      expect(result).toHaveProperty('value');
+    });
+
+    it('should read a configuration', async () => {
+      const result = await client.read(testKey);
+      expect(result).toHaveProperty('key', testKey);
+    });
+
+    it('should list configurations', async () => {
+      const result = await client.list();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should delete a configuration', async () => {
+      const result = await client.delete(testKey);
+      expect(result).toHaveProperty('message');
+    });
+  });
+});
+"
+examples/basic-usage.js,"/**
+ * Basic usage example for OpenSecureConf JavaScript Client
+ */
+
+const { OpenSecureConfClient } = require('opensecureconf-client');
+
+async function main() {
+  // Initialize the client
+  const client = new OpenSecureConfClient({
+    baseUrl: 'http://localhost:9000',
+    userKey: 'my-secure-encryption-key',
+    apiKey: 'your-super-secret-api-key-here', // Optional
+  });
+
+  try {
+    // Create a new configuration
+    const created = await client.create(
+      'database-config',
+      {
+        host: 'localhost',
+        port: 5432,
+        database: 'myapp',
+        ssl: true,
+      },
+      'database'
+    );
+    console.log('Created:', created);
+
+    // Read a configuration
+    const config = await client.read('database-config');
+    console.log('Read:', config);
+
+    // List all configurations
+    const all = await client.list();
+    console.log('All configs:', all.length);
+
+    // Delete a configuration
+    await client.delete('database-config');
+    console.log('Deleted successfully');
+
+  } catch (error) {
+    if (error.name === 'OpenSecureConfError') {
+      console.error('API Error:', error.statusCode, error.message);
+    } else {
+      console.error('Error:', error);
+    }
+  }
+}
+
+main();
+"
+examples/advanced-usage.ts,"/**
+ * Advanced usage example with TypeScript
+ */
+
+import OpenSecureConfClient, {
+  ConfigEntry,
+  OpenSecureConfError,
+} from 'opensecureconf-client';
+
+interface DatabaseConfig {
+  host: string;
+  port: number;
+  database: string;
+  ssl: boolean;
+}
+
+class ConfigManager {
+  private client: OpenSecureConfClient;
+
+  constructor(baseUrl: string, userKey: string, apiKey?: string) {
+    this.client = new OpenSecureConfClient({
+      baseUrl,
+      userKey,
+      apiKey,
+    });
+  }
+
+  async getDatabaseConfig(key: string): Promise<DatabaseConfig> {
+    const config = await this.client.read(key);
+    return config.value as DatabaseConfig;
+  }
+
+  async setDatabaseConfig(key: string, config: DatabaseConfig): Promise<void> {
+    await this.client.create(key, config as Record<string, any>, 'database');
+  }
+
+  async withRetry<T>(
+    operation: () => Promise<T>,
+    maxRetries: number = 3
+  ): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error as Error;
+
+        if (error instanceof OpenSecureConfError) {
+          if (error.statusCode >= 400 && error.statusCode < 500) {
+            throw error;
+          }
+        }
+
+        if (i < maxRetries - 1) {
+          await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
+        }
+      }
+    }
+
+    throw lastError;
+  }
+}
+
+async function main() {
+  const manager = new ConfigManager(
+    'http://localhost:9000',
+    'my-secure-encryption-key',
+    'your-super-secret-api-key-here'
+  );
+
+  try {
+    await manager.setDatabaseConfig('prod-db', {
+      host: 'db.example.com',
+      port: 5432,
+      database: 'production',
+      ssl: true,
+    });
+
+    const dbConfig = await manager.getDatabaseConfig('prod-db');
+    console.log('Database config:', dbConfig);
+
+  } catch (error) {
+    if (error instanceof OpenSecureConfError) {
+      console.error(`API Error [${error.statusCode}]:`, error.detail);
+    } else {
+      console.error('Error:', error);
+    }
+  }
+}
+
+main();

package/dist/index.d.mts

@@ -0,0 +1,72 @@
+/**
+ * OpenSecureConf JavaScript/TypeScript Client
+ *
+ * A comprehensive REST API client for OpenSecureConf - Encrypted configuration
+ * management system with cluster support.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * Configuration entry interface
+ */
+interface ConfigEntry {
+    id?: number;
+    key: string;
+    value: Record<string, any>;
+    category?: string;
+}
+/**
+ * Cluster status information
+ */
+interface ClusterStatus {
+    enabled: boolean;
+    mode?: string;
+    nodeid?: string;
+    totalnodes?: number;
+    healthynodes?: number;
+}
+/**
+ * Client configuration options
+ */
+interface OpenSecureConfOptions {
+    baseUrl: string;
+    userKey: string;
+    apiKey?: string;
+    timeout?: number;
+}
+/**
+ * Custom error class for OpenSecureConf API errors
+ */
+declare class OpenSecureConfError extends Error {
+    statusCode: number;
+    detail?: string;
+    constructor(statusCode: number, message: string, detail?: string);
+}
+/**
+ * OpenSecureConf API Client
+ */
+declare class OpenSecureConfClient {
+    private baseUrl;
+    private userKey;
+    private apiKey?;
+    private timeout;
+    constructor(options: OpenSecureConfOptions);
+    private request;
+    getInfo(): Promise<any>;
+    create(key: string, value: Record<string, any>, category?: string): Promise<ConfigEntry>;
+    read(key: string): Promise<ConfigEntry>;
+    update(key: string, value: Record<string, any>, category?: string): Promise<ConfigEntry>;
+    delete(key: string): Promise<{
+        message: string;
+    }>;
+    list(category?: string): Promise<ConfigEntry[]>;
+    getClusterStatus(): Promise<ClusterStatus>;
+    healthCheck(): Promise<{
+        status: string;
+        nodeid: string;
+    }>;
+    getMetrics(): Promise<string>;
+}
+
+export { type ClusterStatus, type ConfigEntry, OpenSecureConfClient, OpenSecureConfError, type OpenSecureConfOptions, OpenSecureConfClient as default };

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * OpenSecureConf JavaScript/TypeScript Client
+ *
+ * A comprehensive REST API client for OpenSecureConf - Encrypted configuration
+ * management system with cluster support.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * Configuration entry interface
+ */
+interface ConfigEntry {
+    id?: number;
+    key: string;
+    value: Record<string, any>;
+    category?: string;
+}
+/**
+ * Cluster status information
+ */
+interface ClusterStatus {
+    enabled: boolean;
+    mode?: string;
+    nodeid?: string;
+    totalnodes?: number;
+    healthynodes?: number;
+}
+/**
+ * Client configuration options
+ */
+interface OpenSecureConfOptions {
+    baseUrl: string;
+    userKey: string;
+    apiKey?: string;
+    timeout?: number;
+}
+/**
+ * Custom error class for OpenSecureConf API errors
+ */
+declare class OpenSecureConfError extends Error {
+    statusCode: number;
+    detail?: string;
+    constructor(statusCode: number, message: string, detail?: string);
+}
+/**
+ * OpenSecureConf API Client
+ */
+declare class OpenSecureConfClient {
+    private baseUrl;
+    private userKey;
+    private apiKey?;
+    private timeout;
+    constructor(options: OpenSecureConfOptions);
+    private request;
+    getInfo(): Promise<any>;
+    create(key: string, value: Record<string, any>, category?: string): Promise<ConfigEntry>;
+    read(key: string): Promise<ConfigEntry>;
+    update(key: string, value: Record<string, any>, category?: string): Promise<ConfigEntry>;
+    delete(key: string): Promise<{
+        message: string;
+    }>;
+    list(category?: string): Promise<ConfigEntry[]>;
+    getClusterStatus(): Promise<ClusterStatus>;
+    healthCheck(): Promise<{
+        status: string;
+        nodeid: string;
+    }>;
+    getMetrics(): Promise<string>;
+}
+
+export { type ClusterStatus, type ConfigEntry, OpenSecureConfClient, OpenSecureConfError, type OpenSecureConfOptions, OpenSecureConfClient as default };

package/dist/index.js

@@ -0,0 +1,167 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OpenSecureConfClient: () => OpenSecureConfClient,
+  OpenSecureConfError: () => OpenSecureConfError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var OpenSecureConfError = class _OpenSecureConfError extends Error {
+  constructor(statusCode, message, detail) {
+    super(message);
+    this.name = "OpenSecureConfError";
+    this.statusCode = statusCode;
+    this.detail = detail;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _OpenSecureConfError);
+    }
+  }
+};
+var OpenSecureConfClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.userKey = options.userKey;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout || 3e4;
+    if (!this.userKey || this.userKey.length < 8) {
+      throw new Error("userKey must be at least 8 characters long");
+    }
+  }
+  async request(method, endpoint, body) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-User-Key": this.userKey
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorDetail;
+        try {
+          const errorData = await response.json();
+          errorDetail = errorData.detail || errorData.message;
+        } catch {
+          errorDetail = response.statusText;
+        }
+        throw new OpenSecureConfError(
+          response.status,
+          `HTTP ${response.status}: ${response.statusText}`,
+          errorDetail
+        );
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof OpenSecureConfError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new OpenSecureConfError(
+            408,
+            "Request timeout",
+            `Request exceeded ${this.timeout}ms`
+          );
+        }
+        throw new OpenSecureConfError(0, "Network error", error.message);
+      }
+      throw error;
+    }
+  }
+  async getInfo() {
+    return this.request("GET", "/");
+  }
+  async create(key, value, category) {
+    return this.request("POST", "/configs", {
+      key,
+      value,
+      category
+    });
+  }
+  async read(key) {
+    return this.request("GET", `/configs/${encodeURIComponent(key)}`);
+  }
+  async update(key, value, category) {
+    return this.request("PUT", `/configs/${encodeURIComponent(key)}`, {
+      value,
+      category
+    });
+  }
+  async delete(key) {
+    return this.request("DELETE", `/configs/${encodeURIComponent(key)}`);
+  }
+  async list(category) {
+    const endpoint = category ? `/configs?category=${encodeURIComponent(category)}` : "/configs";
+    return this.request("GET", endpoint);
+  }
+  async getClusterStatus() {
+    return this.request("GET", "/cluster/status");
+  }
+  async healthCheck() {
+    return this.request("GET", "/cluster/health");
+  }
+  async getMetrics() {
+    const url = `${this.baseUrl}/metrics`;
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new OpenSecureConfError(
+        response.status,
+        `Failed to fetch metrics: ${response.statusText}`
+      );
+    }
+    return await response.text();
+  }
+};
+var index_default = OpenSecureConfClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenSecureConfClient,
+  OpenSecureConfError
+});
+/**
+ * OpenSecureConf JavaScript/TypeScript Client
+ *
+ * A comprehensive REST API client for OpenSecureConf - Encrypted configuration
+ * management system with cluster support.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */

package/dist/index.mjs

@@ -0,0 +1,141 @@
+// src/index.ts
+var OpenSecureConfError = class _OpenSecureConfError extends Error {
+  constructor(statusCode, message, detail) {
+    super(message);
+    this.name = "OpenSecureConfError";
+    this.statusCode = statusCode;
+    this.detail = detail;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _OpenSecureConfError);
+    }
+  }
+};
+var OpenSecureConfClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.userKey = options.userKey;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout || 3e4;
+    if (!this.userKey || this.userKey.length < 8) {
+      throw new Error("userKey must be at least 8 characters long");
+    }
+  }
+  async request(method, endpoint, body) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-User-Key": this.userKey
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorDetail;
+        try {
+          const errorData = await response.json();
+          errorDetail = errorData.detail || errorData.message;
+        } catch {
+          errorDetail = response.statusText;
+        }
+        throw new OpenSecureConfError(
+          response.status,
+          `HTTP ${response.status}: ${response.statusText}`,
+          errorDetail
+        );
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof OpenSecureConfError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new OpenSecureConfError(
+            408,
+            "Request timeout",
+            `Request exceeded ${this.timeout}ms`
+          );
+        }
+        throw new OpenSecureConfError(0, "Network error", error.message);
+      }
+      throw error;
+    }
+  }
+  async getInfo() {
+    return this.request("GET", "/");
+  }
+  async create(key, value, category) {
+    return this.request("POST", "/configs", {
+      key,
+      value,
+      category
+    });
+  }
+  async read(key) {
+    return this.request("GET", `/configs/${encodeURIComponent(key)}`);
+  }
+  async update(key, value, category) {
+    return this.request("PUT", `/configs/${encodeURIComponent(key)}`, {
+      value,
+      category
+    });
+  }
+  async delete(key) {
+    return this.request("DELETE", `/configs/${encodeURIComponent(key)}`);
+  }
+  async list(category) {
+    const endpoint = category ? `/configs?category=${encodeURIComponent(category)}` : "/configs";
+    return this.request("GET", endpoint);
+  }
+  async getClusterStatus() {
+    return this.request("GET", "/cluster/status");
+  }
+  async healthCheck() {
+    return this.request("GET", "/cluster/health");
+  }
+  async getMetrics() {
+    const url = `${this.baseUrl}/metrics`;
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new OpenSecureConfError(
+        response.status,
+        `Failed to fetch metrics: ${response.statusText}`
+      );
+    }
+    return await response.text();
+  }
+};
+var index_default = OpenSecureConfClient;
+export {
+  OpenSecureConfClient,
+  OpenSecureConfError,
+  index_default as default
+};
+/**
+ * OpenSecureConf JavaScript/TypeScript Client
+ *
+ * A comprehensive REST API client for OpenSecureConf - Encrypted configuration
+ * management system with cluster support.
+ *
+ * @version 1.0.0
+ * @license MIT
+ */

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "opensecureconf-client",
+  "version": "1.0.0",
+  "description": "JavaScript/TypeScript client for OpenSecureConf - Encrypted configuration management REST API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm test",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "opensecureconf",
+    "configuration",
+    "encryption",
+    "config-management",
+    "rest-api",
+    "client",
+    "typescript",
+    "encrypted-storage",
+    "cluster",
+    "distributed-config"
+  ],
+  "author": "Apioli <alessandro.pioli+apioli-npm@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lordraw77/OpenSecureConf.git",
+    "directory": "client-js"
+  },
+  "bugs": {
+    "url": "https://github.com/lordraw77/OpenSecureConf/issues"
+  },
+  "homepage": "https://github.com/lordraw77/OpenSecureConf/tree/main/client-js#readme",
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.2",
+    "jest": "^29.7.0",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "opensecureconf-client": "file:opensecureconf-client-1.0.0.tgz"
+  }
+}