pass-manager-cli 1.0.1 → 1.0.3

package/README.md

@@ -1,13 +1,16 @@
 # Password Manager CLI (PMC)
 
-A command-line interface (CLI) tool for managing your passwords efficiently. This tool allows you to add, list, copy, and delete passwords, as well as link to your password manager's host.
+A secure command-line interface (CLI) tool for managing your passwords efficiently.
+
+[Github Repo Link](https://github.com/Ajinkyap331/password-manager-cli)
 
 ## Features
 
-- **Secure Password Management**: Add, list, copy, and delete passwords.
-- **Host Configuration**: Easily link your CLI to a password manager backend by specifying its host IP.
+- **End-to-End Encryption**: All passwords are encrypted with **AES-256-GCM** using a Master Password.
+- **System Keychain Integration**: Securely store your Master Password in your OS keychain (macOS, Windows, or Linux) for seamless access.
+- **Interactive Mode**: Securely add passwords via interactive prompts to keep them out of your terminal history.
 - **Clipboard Integration**: Copy passwords directly to your clipboard for quick use.
-- **Modular Structure**: Built with a clear separation of concerns for easy maintenance and extensibility.
+- **Standalone Local Storage**: Your vault is stored locally in `~/.config/pmc/passwords.json`.
 
 ## Installation
 
@@ -23,6 +26,72 @@ just setup
 pmc --help
 ```
 
-### API Contract
+## User Guide
+
+### 1. Setup & Adding Passwords
+The safest way to add a password is using the interactive mode. This prevents your password from being saved in your terminal history.
+
+```bash
+pmc add
+```
+*You will be prompted for the URL, Username, and Password.*
+
+### 2. Listing Passwords
+To see all your stored accounts (passwords remain hidden):
+
+```bash
+pmc list
+```
+*Note the **index** number of the entry you want to use.*
+
+### 3. Copying to Clipboard
+To use a password, copy it directly to your clipboard using its index:
+
+```bash
+pmc copy <index>
+```
+*Example: `pmc copy 0`*
+
+### 4. Updating an Entry
+If you change a password or username:
+
+```bash
+pmc update <index>
+```
+*This will prompt you with the current values, which you can edit or keep.*
+
+### 5. Deleting an Entry
+To remove a password permanently:
+
+```bash
+pmc delete <index>
+```
+
+### 6. Serving via HTTP
+Start a local HTTP server to interact with other applications (e.g., UI or browser extensions).
+
+```bash
+pmc serve
+```
+*Starts a server at `http://localhost:7474`. You can query passwords via `GET /password?url=<url>`.*
+
+---
+
+### Security Tip: The Master Password
+The first time you use PMC, you'll create a **Master Password**.
+- **Keychain:** We recommend saying "Yes" when asked to save it to the System Keychain. This allows you to use PMC without typing your Master Password every time.
+- **Lost Password:** If you lose your Master Password, **your data cannot be recovered**. Keep it safe!
+
+## Contribution
+
+Contributions are welcome! If you'd like to improve PMC, please follow these steps:
+
+1. **[Fork the repository](https://github.com/Ajinkyap331/password-manager-cli)** on GitHub.
+2. **Clone your fork** locally: `git clone https://github.com/YOUR_USERNAME/password-manager-cli.git`.
+3. **Create a new branch** for your feature or bugfix: `git checkout -b feature-name`.
+4. **Make your changes** and ensure everything works as expected.
+5. **Commit your changes**: `git commit -m "Add feature name"`.
+6. **Push to your branch**: `git push origin feature-name`.
+7. **Create a Pull Request** on the original repository.
 
-For details on the backend API endpoints and data structures that this CLI interacts with, please refer to the [API Contract Documentation](https://github.com/Ajinkyap331/password-manager-cli/blob/main/docs/API_CONTRACT.md).
+Please ensure your code follows the existing style and structure of the project.

package/index.js

@@ -10,4 +10,4 @@ program
   .description("CLI for Password Manager")
   .version("1.0.0");
 
-init(program);
+init(program);

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "pass-manager-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "type": "module",
   "main": "index.js",
-  "scripts": {},
+  "scripts": {
+    "test": "node --test tests/*.test.js"
+  },
   "keywords": [],
   "author": "",
   "license": "ISC",
@@ -12,10 +14,11 @@
     "pmc": "./index.js"
   },
   "dependencies": {
-    "axios": "^1.13.2",
+    "@inquirer/prompts": "^8.1.0",
     "clipboardy": "^5.0.2",
     "commander": "^14.0.2",
-    "inquirer": "^13.1.0",
-    "node-persist": "^4.0.4"
+    "express": "^5.2.1",
+    "keytar": "^7.9.0",
+    "lowdb": "^7.0.1"
   }
 }

package/src/commands/passwords.js

@@ -1,8 +1,9 @@
 import {
-  addPassword,
   listPasswords,
+  addPassword,
   copyPassword,
   deletePassword,
+  updatePassword,
 } from "../services/passwordService.js";
 
 export const passwordCommands = (program) => {
@@ -14,9 +15,9 @@ export const passwordCommands = (program) => {
   program
     .command("add")
     .description("add a password")
-    .argument("url", "url")
-    .argument("username", "username")
-    .argument("password", "password")
+    .argument("[url]", "url")
+    .argument("[username]", "username")
+    .argument("[password]", "password")
     .action(addPassword);
 
   program
@@ -30,4 +31,10 @@ export const passwordCommands = (program) => {
     .description("Delete Password")
     .argument("index", "index")
     .action(deletePassword);
-};
+
+  program
+    .command("update")
+    .description("Update password entry")
+    .argument("index", "index")
+    .action(updatePassword);
+};

package/src/commands/serve.js

@@ -0,0 +1,33 @@
+import express from "express";
+import { getPasswords } from "../lib/storage.js";
+export const app = express();
+const PORT = 7474;
+
+export const serverCommands = (program) => {
+  program
+    .command("serve")
+    .description("Create a server to interact with UI")
+    .action(startServer);
+};
+
+app.get("/password", async (req, res) => {
+  const url = req.query.url;
+  console.log(url);
+  try {
+    const allPasswords = await getPasswords();
+    const passwords = allPasswords.filter((password) => password.url === url);
+    res.send(passwords);
+  } catch (error) {
+    res.status(500).send({ error: error.message });
+  }
+});
+
+const startServer = async () => {
+  try {
+    app.listen(PORT, "127.0.0.1", () => {
+      console.log(`Server running at http://127.0.0.1:${PORT}/`);
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error.message);
+  }
+};

package/src/config.js

@@ -0,0 +1,15 @@
+import os from "os";
+import path from "path";
+
+export const SERVICE_NAME = "PMC-CLI";
+export const ACCOUNT_NAME = "MasterPassword";
+
+export const HOME_DIRECTORY = os.homedir();
+export const STORAGE_DIRECTORY = path.join(
+  HOME_DIRECTORY,
+  ".config",
+  "pmc",
+  "passwords.json"
+);
+
+export const DEFAULT_DATA = { vault: null };

package/src/lib/commands.js

@@ -1,8 +1,8 @@
 import { passwordCommands } from "../commands/passwords.js";
-import { hostCommands } from "../commands/host.js";
+import { serverCommands } from "../commands/serve.js";
 
 export const init = (program) => {
   passwordCommands(program);
-  hostCommands(program);
+  serverCommands(program);
   program.parse();
 };

package/src/lib/storage.js

@@ -1,39 +1,113 @@
-import nodePersist from "node-persist";
-import os from "os";
-import path from "path";
+import { password as passwordPrompt, confirm } from "@inquirer/prompts";
+import { vaultEncryption } from "../utils/crypto.js";
+import keytar from "keytar";
+import {
+  getMasterPasswordPrompt,
+  saveToKeychainPrompt,
+} from "../utils/prompts.js";
+import { JSONFilePreset } from "lowdb/node";
+import {
+  SERVICE_NAME,
+  ACCOUNT_NAME,
+  STORAGE_DIRECTORY,
+  DEFAULT_DATA,
+} from "../config.js";
+import { DecryptionError } from "../utils/errors.js";
 
-let isInitialized = false;
+const getMasterPassword = async (isNew = false) => {
+  if (!isNew) {
+    const storedPassword = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+    if (storedPassword) {
+      return storedPassword;
+    }
+  }
 
-const initStorage = async () => {
-  if (!isInitialized) {
-    const homeDirectory = os.homedir();
-    const storageDirectory = path.join(homeDirectory, ".config", "pmc");
-
-    await nodePersist.init({
-      dir: storageDirectory,
-      logging: false,
-      ttl: false,
-    });
-    isInitialized = true;
+  const masterPassword = await passwordPrompt(getMasterPasswordPrompt(isNew));
+
+  const shouldSave = await confirm(saveToKeychainPrompt);
+
+  if (shouldSave) {
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, masterPassword);
+    console.log("Master Password saved to System Keychain.");
   }
+
+  return masterPassword;
 };
 
-export const setItem = async (key, value) => {
-  await initStorage();
-  return nodePersist.setItem(key, value);
+const initStorage = async () => {
+  const db = await JSONFilePreset(STORAGE_DIRECTORY, DEFAULT_DATA);
+  return db;
 };
 
-export const getItem = async (key) => {
-  await initStorage();
-  return nodePersist.getItem(key);
+export const addItem = async (newPasswordEntry) => {
+  const db = await initStorage();
+  const isNew = !db.data.vault;
+
+  const masterPassword = await getMasterPassword(isNew);
+
+  let passwords = [];
+  if (!isNew) {
+    passwords = await vaultEncryption.decrypt(db.data.vault, masterPassword);
+  }
+
+  passwords.push(newPasswordEntry);
+
+  const encryptedVault = await vaultEncryption.encrypt(passwords, masterPassword);
+  await db.update((data) => {
+    data.vault = encryptedVault;
+  });
 };
 
-export const clear = async () => {
-  await initStorage();
-  return nodePersist.clear();
+export const getPasswords = async () => {
+  const db = await initStorage();
+  if (!db.data.vault) {
+    console.log("Vault is empty.");
+    return [];
+  }
+
+  const masterPassword = await getMasterPassword();
+
+  try {
+    return await vaultEncryption.decrypt(db.data.vault, masterPassword);
+  } catch (error) {
+    if (error instanceof DecryptionError) {
+      await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+      throw new DecryptionError(
+        "Decryption failed. The master password may be incorrect or the vault is corrupted. Stored keychain password has been cleared."
+      );
+    }
+    throw error;
+  }
 };
 
-export const getHostIP = async () => {
-  await initStorage();
-  return nodePersist.getItem("host");
-};
+export const clear = async (indexToRemove) => {
+  const db = await initStorage();
+  if (!db.data.vault) return;
+
+  const masterPassword = await getMasterPassword();
+  let passwords = await vaultEncryption.decrypt(db.data.vault, masterPassword);
+
+  if (indexToRemove >= 0 && indexToRemove < passwords.length) {
+    passwords.splice(indexToRemove, 1);
+    const encryptedVault = await vaultEncryption.encrypt(passwords, masterPassword);
+    await db.update((data) => {
+      data.vault = encryptedVault;
+    });
+  }
+};
+
+export const updateItem = async (indexToUpdate, updatedEntry) => {
+  const db = await initStorage();
+  if (!db.data.vault) return;
+
+  const masterPassword = await getMasterPassword();
+  let passwords = await vaultEncryption.decrypt(db.data.vault, masterPassword);
+
+  if (indexToUpdate >= 0 && indexToUpdate < passwords.length) {
+    passwords[indexToUpdate] = { ...passwords[indexToUpdate], ...updatedEntry };
+    const encryptedVault = await vaultEncryption.encrypt(passwords, masterPassword);
+    await db.update((data) => {
+      data.vault = encryptedVault;
+    });
+  }
+};

package/src/services/passwordService.js

@@ -1,37 +1,59 @@
+import { input, password as passwordPrompt } from "@inquirer/prompts";
 import {
   getPasswords,
-  createPassword,
-  deletePasswordById,
-} from "../lib/api.js";
+  addItem,
+  clear,
+  updateItem,
+} from "../lib/storage.js";
 import { copyToClipboard } from "../utils/clipboard.js";
+import {
+  urlPrompt,
+  usernamePrompt,
+  passwordPromptConfig,
+  getUpdateUsernamePrompt,
+  updatePasswordPromptConfig,
+} from "../utils/prompts.js";
 
-export const addPassword = async (url, username, password) => {
+export const listPasswords = async () => {
   try {
-    await createPassword(url, username, password);
-    console.log("Password added successfully.");
+    const passwords = await getPasswords();
+    console.table(passwords, ["url", "username"]);
   } catch (error) {
-    console.error("Failed to add password:", error.message);
+    console.error("Failed to list passwords:", error.message);
   }
 };
 
-export const listPasswords = async () => {
+export const addPassword = async (url, username, password) => {
   try {
-    const passwords = await getPasswords();
-    console.table(passwords, ["url", "username"]);
+    const finalUrl = url || (await input(urlPrompt));
+    const finalUsername = username || (await input(usernamePrompt));
+    const finalPassword =
+      password || (await passwordPrompt(passwordPromptConfig));
+
+    const newPasswordEntry = {
+      url: finalUrl,
+      username: finalUsername,
+      password: finalPassword,
+    };
+    await addItem(newPasswordEntry);
+    console.log("Password added successfully.");
   } catch (error) {
-    console.error("Failed to list passwords:", error.message);
+    console.error("Failed to add password:", error.message);
   }
 };
 
 export const copyPassword = async (index) => {
   try {
     const passwords = await getPasswords();
+    const i = parseInt(index, 10);
 
-    if (index >= 0 && index < passwords.length) {
-      const password = passwords[index].password;
+    if (!isNaN(i) && i >= 0 && i < passwords.length) {
+      const password = passwords[i].password;
       const success = await copyToClipboard(password);
       if (success) console.log("Password copied to clipboard.");
-    } else console.error("Invalid index provided.");
+    } else {
+      console.error("Invalid index provided.");
+    }
   } catch (error) {
     console.error("Failed to copy password:", error.message);
   }
@@ -40,13 +62,46 @@ export const copyPassword = async (index) => {
 export const deletePassword = async (index) => {
   try {
     const passwords = await getPasswords();
+    const i = parseInt(index, 10);
 
-    if (index >= 0 && index < passwords.length) {
-      const passwordId = passwords[index].id;
-      await deletePasswordById(passwordId);
+    if (!isNaN(i) && i >= 0 && i < passwords.length) {
+      await clear(i);
       console.log("Password deleted successfully.");
-    } else console.error("Invalid index provided.");
+    } else {
+      console.error("Invalid index provided.");
+    }
   } catch (error) {
     console.error("Failed to delete password:", error.message);
   }
 };
+
+export const updatePassword = async (index) => {
+  try {
+    const passwords = await getPasswords();
+    const i = parseInt(index, 10);
+
+    if (!isNaN(i) && i >= 0 && i < passwords.length) {
+      const current = passwords[i];
+      const updates = {};
+
+      const newUsername = await input(
+        getUpdateUsernamePrompt(current.username)
+      );
+      if (newUsername) updates.username = newUsername;
+
+      const newPassword = await passwordPrompt(updatePasswordPromptConfig);
+      if (newPassword) updates.password = newPassword;
+
+      if (Object.keys(updates).length > 0) {
+        await updateItem(i, updates);
+        console.log("Password entry updated successfully.");
+      } else {
+        console.log("No changes made.");
+      }
+    } else {
+      console.error("Invalid index provided.");
+    }
+  } catch (error) {
+    console.error("Failed to update password:", error.message);
+  }
+};

package/src/utils/crypto.js

@@ -0,0 +1,73 @@
+import crypto from "crypto";
+import { promisify } from "util";
+import { DecryptionError } from "./errors.js";
+
+const pbkdf2 = promisify(crypto.pbkdf2);
+
+export class VaultEncryption {
+  constructor() {
+    this.ALGORITHM = "aes-256-gcm";
+    this.KEY_LENGTH = 32;
+    this.SALT_LENGTH = 16;
+    this.IV_LENGTH = 12;
+    this.ITERATIONS = 100000;
+  }
+
+  async encrypt(data, password) {
+    const salt = crypto.randomBytes(this.SALT_LENGTH);
+    const iv = crypto.randomBytes(this.IV_LENGTH);
+
+    const key = await pbkdf2(
+      password,
+      salt,
+      this.ITERATIONS,
+      this.KEY_LENGTH,
+      "sha256"
+    );
+    const cipher = crypto.createCipheriv(this.ALGORITHM, key, iv);
+
+    const encrypted = Buffer.concat([
+      cipher.update(JSON.stringify(data), "utf8"),
+      cipher.final(),
+    ]);
+
+    const authTag = cipher.getAuthTag();
+
+    return {
+      salt: salt.toString("hex"),
+      iv: iv.toString("hex"),
+      authTag: authTag.toString("hex"),
+      encryptedData: encrypted.toString("hex"),
+    };
+  }
+
+  async decrypt(vault, password) {
+    const salt = Buffer.from(vault.salt, "hex");
+    const iv = Buffer.from(vault.iv, "hex");
+    const authTag = Buffer.from(vault.authTag, "hex");
+    const encryptedData = Buffer.from(vault.encryptedData, "hex");
+
+    const key = await pbkdf2(
+      password,
+      salt,
+      this.ITERATIONS,
+      this.KEY_LENGTH,
+      "sha256"
+    );
+    const decipher = crypto.createDecipheriv(this.ALGORITHM, key, iv);
+
+    decipher.setAuthTag(authTag);
+
+    try {
+      const decrypted = Buffer.concat([
+        decipher.update(encryptedData),
+        decipher.final(),
+      ]);
+      return JSON.parse(decrypted.toString("utf8"));
+    } catch (error) {
+      throw new DecryptionError("Invalid master password or corrupted data.");
+    }
+  }
+}
+
+export const vaultEncryption = new VaultEncryption();

package/src/utils/errors.js

@@ -0,0 +1,24 @@
+export class AppError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+export class DecryptionError extends AppError {
+  constructor(message = "Decryption failed.") {
+    super(message);
+  }
+}
+
+export class KeychainError extends AppError {
+  constructor(message = "Keychain operation failed.") {
+    super(message);
+  }
+}
+
+export class StorageError extends AppError {
+  constructor(message = "Storage operation failed.") {
+    super(message);
+  }
+}

package/src/utils/prompts.js

@@ -0,0 +1,26 @@
+export const urlPrompt = { message: "Enter URL (e.g., google.com):" };
+
+export const usernamePrompt = { message: "Enter Username:" };
+
+export const passwordPromptConfig = { message: "Enter Password:", mask: "*" };
+
+export const getUpdateUsernamePrompt = (currentUsername) => ({
+  message: `Enter Username (leave empty to keep: ${currentUsername}):`,
+});
+
+export const updatePasswordPromptConfig = {
+  message: "Enter New Password (leave empty to keep current):",
+  mask: "*",
+};
+
+export const getMasterPasswordPrompt = (isNew) => ({
+  message: isNew
+    ? "Create a new Master Password for your vault:"
+    : "Enter your Master Password to unlock the vault:",
+  mask: "*",
+});
+
+export const saveToKeychainPrompt = {
+  message: "Save Master Password to System Keychain?",
+  default: true,
+};

package/tests/crypto.test.js

@@ -0,0 +1,47 @@
+import { vaultEncryption } from "../src/utils/crypto.js";
+import { DecryptionError } from "../src/utils/errors.js";
+import assert from "node:assert";
+import test from "node:test";
+
+test("VaultEncryption - encrypt and decrypt", async (t) => {
+  const data = { secret: "my-password-123" };
+  const password = "master-password";
+
+  await t.test("should successfully encrypt and then decrypt data", async () => {
+    const encrypted = await vaultEncryption.encrypt(data, password);
+    
+    assert.ok(encrypted.salt, "should have salt");
+    assert.ok(encrypted.iv, "should have iv");
+    assert.ok(encrypted.authTag, "should have authTag");
+    assert.ok(encrypted.encryptedData, "should have encryptedData");
+
+    const decrypted = await vaultEncryption.decrypt(encrypted, password);
+    assert.deepStrictEqual(decrypted, data, "decrypted data should match original data");
+  });
+
+  await t.test("should throw DecryptionError with incorrect password", async () => {
+    const encrypted = await vaultEncryption.encrypt(data, password);
+    
+    await assert.rejects(
+      async () => {
+        await vaultEncryption.decrypt(encrypted, "wrong-password");
+      },
+      {
+        name: "DecryptionError",
+        message: "Invalid master password or corrupted data.",
+      }
+    );
+  });
+
+  await t.test("should throw error with corrupted data", async () => {
+    const encrypted = await vaultEncryption.encrypt(data, password);
+    const corruptedVault = { ...encrypted, encryptedData: "corrupted" };
+
+    await assert.rejects(
+      async () => {
+        await vaultEncryption.decrypt(corruptedVault, password);
+      },
+      DecryptionError
+    );
+  });
+});

package/docs/API_CONTRACT.md

@@ -1,99 +0,0 @@
-# Backend API Contract for Password Manager CLI
-
-This document outlines the API endpoints, methods, and data structures expected from the backend service that the Password Manager CLI (PMC) interacts with.
-
-**Base URL Structure:** `http://<hostIP>:5421/`
-
-The `<hostIP>` is configured using the `pmc host link <IP_ADDRESS>` command.
-
----
-
-## 1. Passwords API
-
-This API is responsible for managing password entries.
-
-### a. `GET /passwords` - Retrieve All Passwords
-
-Retrieves a list of all password entries stored in the backend.
-
-*   **Method:** `GET`
-*   **Path:** `/passwords`
-*   **Authentication:** (Assumed to be handled by backend, not explicitly defined in current CLI)
-*   **Request Headers:** (None explicitly sent by CLI for now, could include Authorization in future)
-*   **Request Body:** (None)
-*   **Response:** `200 OK` - A JSON array of password objects.
-
-    ```json
-    [
-      {
-        "id": "uuid-v4-string-1",
-        "url": "example.com",
-        "username": "user@example.com",
-        "password": "secure_password_1"
-      },
-      {
-        "id": "uuid-v4-string-2",
-        "url": "another.com",
-        "username": "another_user",
-        "password": "secure_password_2"
-      },
-      // ... more password objects
-    ]
-    ```
-
-### b. `POST /passwords` - Add a New Password
-
-Adds a new password entry to the backend.
-
-*   **Method:** `POST`
-*   **Path:** `/passwords`
-*   **Authentication:** (Assumed)
-*   **Request Headers:**
-    *   `Content-Type: application/json`
-*   **Request Body:** A JSON object containing the new password's details.
-
-    ```json
-    {
-      "url": "new-site.com",
-      "username": "new_user",
-      "password": "new_secure_password"
-    }
-    ```
-*   **Response:** `200 OK` or `201 Created` - The newly created password object, including its generated `id`.
-
-    ```json
-    {
-      "id": "uuid-v4-string-3",
-      "url": "new-site.com",
-      "username": "new_user",
-      "password": "new_secure_password"
-    }
-    ```
-
-### c. `DELETE /passwords/:id` - Delete a Password by ID
-
-Deletes a specific password entry from the backend using its unique ID.
-
-*   **Method:** `DELETE`
-*   **Path:** `/passwords/{id}` (where `{id}` is the unique identifier of the password)
-*   **Authentication:** (Assumed)
-*   **Request Headers:** (None)
-*   **Request Body:** (None)
-*   **Response:** `200 OK` (or `204 No Content`) - Indicates successful deletion. No content is typically returned for 204.
-
-    ```json
-    // Example for 200 OK
-    {
-      "message": "Password deleted successfully"
-    }
-    ```
-    or
-    (No Content for 204)
-
----
-
-## 2. Host Configuration
-
-The `pmc host link <IP_ADDRESS>` command primarily configures the local CLI's storage to remember the backend server's IP address. There is no explicit "Host API" endpoint for this action in the backend. The `hostIP` is used by the CLI to construct the base URL for the Passwords API.
-
----

package/mise.toml

@@ -1,2 +0,0 @@
-[tools]
-node = "24"

package/src/commands/host.js

@@ -1,9 +0,0 @@
-import { linkManager } from "../services/hostService.js";
-
-export const hostCommands = (program) => {
-  program
-    .command("link")
-    .description("link a password manager")
-    .argument("ip", "ip")
-    .action(linkManager);
-};

package/src/lib/api.js

@@ -1,28 +0,0 @@
-import axios from "axios";
-import { getHostIP } from "./storage.js";
-
-const getBaseUrl = async () => {
-  const hostIP = await getHostIP();
-  if (!hostIP) {
-    throw new Error("Host IP not set. Please link a password manager first.");
-  }
-  return `http://${hostIP}:5421/passwords`;
-};
-
-export const getPasswords = async () => {
-  const url = await getBaseUrl();
-  const response = await axios.get(url);
-  return response.data;
-};
-
-export const createPassword = async (url, username, password) => {
-  const baseUrl = await getBaseUrl();
-  const response = await axios.post(baseUrl, { url, username, password });
-  return response.data;
-};
-
-export const deletePasswordById = async (id) => {
-  const baseUrl = await getBaseUrl();
-  const response = await axios.delete(`${baseUrl}/${id}`);
-  return response.data;
-};

package/src/services/hostService.js

@@ -1,10 +0,0 @@
-import { setItem } from "../lib/storage.js";
-
-export const linkManager = async (ip) => {
-  try {
-    await setItem("host", ip);
-    console.log(`Host IP ${ip} linked successfully.`);
-  } catch (error) {
-    console.error("Failed to link host IP:", error.message);
-  }
-};