bitty-tui 0.0.15 → 0.0.17

package/dist/clients/bw.js

@@ -17,7 +17,6 @@
  *  - Cipher-specific key if available
  * 4. Decrypt cipher fields using the chosen key
  */
-import https from "node:https";
 import crypto from "node:crypto";
 import * as argon2 from "argon2";
 export class FetchError extends Error {
@@ -32,54 +31,14 @@ export class FetchError extends Error {
         return JSON.parse(this.data);
     }
 }
-function fetch(url, options = {}, body = null) {
-    return new Promise((resolve, reject) => {
-        const urlObj = new URL(url);
-        const requestOptions = {
-            hostname: urlObj.hostname,
-            path: urlObj.pathname + urlObj.search,
-            method: options.method || "GET",
-            headers: options.headers || {},
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            const onData = (chunk) => {
-                data += chunk;
-            };
-            const onEnd = () => {
-                cleanup();
-                if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
-                    reject(new FetchError(res.statusCode, data, `HTTP error: ${res.statusCode} ${res.statusMessage}`));
-                    return;
-                }
-                resolve({
-                    status: res.statusCode,
-                    json: () => Promise.resolve(JSON.parse(data)),
-                    text: () => Promise.resolve(data),
-                });
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const cleanup = () => {
-                res.removeListener("data", onData);
-                res.removeListener("end", onEnd);
-                res.removeListener("error", onError);
-            };
-            res.on("data", onData);
-            res.on("end", onEnd);
-            res.on("error", onError);
-        });
-        req.on("error", (error) => {
-            reject(error);
-        });
-        if (body) {
-            req.write(typeof body === "string" ? body : JSON.stringify(body));
-        }
-        req.end();
-    });
-}
+const fetchApi = async (...args) => {
+    const response = await fetch(...args);
+    if (!response.ok) {
+        const data = await response.text();
+        throw new FetchError(response.status, data);
+    }
+    return response;
+};
 export var CipherType;
 (function (CipherType) {
     CipherType[CipherType["Login"] = 1] = "Login";
@@ -409,13 +368,12 @@ export class Client {
     async login(email, password, skipPrelogin = false, opts) {
         let keys = this.keys;
         if (!skipPrelogin) {
-            const prelogin = await fetch(`${this.identityUrl}/accounts/prelogin`, {
+            const prelogin = await fetchApi(`${this.identityUrl}/accounts/prelogin`, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                 },
-            }, {
-                email,
+                body: JSON.stringify({ email }),
             }).then((r) => r.json());
             keys = await mcbw.deriveMasterKey(email, password, prelogin);
             this.keys = keys;
@@ -432,16 +390,22 @@ export class Client {
         for (const [key, value] of Object.entries(opts || {})) {
             bodyParams.append(key, value);
         }
-        const identityReq = await fetch(`${this.identityUrl}/connect/token`, {
+        const identityReq = await fetchApi(`${this.identityUrl}/connect/token`, {
             method: "POST",
             headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
+                accept: "*/*",
+                "accept-language": "en-US",
+                "bitwarden-client-name": "web",
+                "bitwarden-client-version": "2025.9.0",
+                "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
             },
-        }, bodyParams.toString()).then((r) => r.json());
+            body: bodyParams.toString(),
+        }).then((r) => r.json());
         this.token = identityReq.access_token;
         this.refreshToken = identityReq.refresh_token;
         this.tokenExpiration = Date.now() + identityReq.expires_in * 1000;
         const { userKey, privateKey } = mcbw.decodeUserKeys(identityReq.Key, identityReq.PrivateKey || "", keys);
+        keys.masterKey = undefined; // Clear master key from memory
         this.keys = {
             ...keys,
             userKey,
@@ -452,19 +416,20 @@ export class Client {
         this.orgKeys = {};
     }
     async sendEmailMfaCode(email) {
-        fetch(`${this.apiUrl}/two-factor/send-email-login`, {
+        fetchApi(`${this.apiUrl}/two-factor/send-email-login`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
-        }, JSON.stringify({
-            email: email,
-            masterPasswordHash: this.keys.masterPasswordHash,
-            ssoEmail2FaSessionToken: "",
-            deviceIdentifier: DEVICE_IDENTIFIER,
-            authRequestAccessCode: "",
-            authRequestId: "",
-        }));
+            body: JSON.stringify({
+                email: email,
+                masterPasswordHash: this.keys.masterPasswordHash,
+                ssoEmail2FaSessionToken: "",
+                deviceIdentifier: DEVICE_IDENTIFIER,
+                authRequestAccessCode: "",
+                authRequestId: "",
+            }),
+        });
     }
     // Check and refresh token if needed
     async checkToken() {
@@ -472,12 +437,13 @@ export class Client {
             if (!this.refreshToken) {
                 throw new Error("No refresh token available. Please login first.");
             }
-            const identityReq = await fetch(`${this.identityUrl}/connect/token`, {
+            const identityReq = await fetchApi(`${this.identityUrl}/connect/token`, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/x-www-form-urlencoded",
                 },
-            }, `refresh_token=${this.refreshToken}&grant_type=refresh_token&client_id=web&scope=api%20offline_access`).then((r) => r.json());
+                body: `refresh_token=${this.refreshToken}&grant_type=refresh_token&client_id=web&scope=api%20offline_access`,
+            }).then((r) => r.json());
             this.token = identityReq.access_token;
             this.refreshToken = identityReq.refresh_token;
             this.tokenExpiration = Date.now() + identityReq.expires_in * 1000;
@@ -490,7 +456,7 @@ export class Client {
      */
     async syncRefresh() {
         await this.checkToken();
-        this.syncCache = await fetch(`${this.apiUrl}/sync?excludeDomains=true`, {
+        this.syncCache = await fetchApi(`${this.apiUrl}/sync?excludeDomains=true`, {
             method: "GET",
             headers: {
                 Authorization: `Bearer ${this.token}`,
@@ -636,13 +602,14 @@ export class Client {
     }
     async createSecret(obj) {
         const key = this.getDecryptionKey(obj);
-        const s = await fetch(`${this.apiUrl}/ciphers`, {
+        const s = await fetchApi(`${this.apiUrl}/ciphers`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${this.token}`,
                 "Content-Type": "application/json",
             },
-        }, this.encryptCipher(obj, key));
+            body: JSON.stringify(this.encryptCipher(obj, key)),
+        });
         return s.json();
     }
     objectDiff(obj1, obj2) {
@@ -682,13 +649,14 @@ export class Client {
         const key = this.getDecryptionKey(patch);
         const data = this.patchObject(original, this.encryptCipher(obj, key));
         data.data = undefined;
-        const s = await fetch(`${this.apiUrl}/ciphers/${id}`, {
+        const s = await fetchApi(`${this.apiUrl}/ciphers/${id}`, {
             method: "PUT",
             headers: {
                 Authorization: `Bearer ${this.token}`,
                 "Content-Type": "application/json",
             },
-        }, data);
+            body: JSON.stringify(data),
+        });
         this.decryptedSyncCache = null;
         this.syncCache = null;
         return s.json();

package/dist/hooks/bw.d.ts

@@ -5,6 +5,12 @@ interface BwConfig {
     refreshToken: string;
 }
 export declare const bwClient: Client;
+export interface LoginHints {
+    email?: string;
+    baseUrl?: string;
+}
+export declare function loadLoginHints(): Promise<LoginHints>;
+export declare function saveLoginHints(hints: LoginHints): Promise<void>;
 export declare function loadConfig(): Promise<boolean>;
 export declare function saveConfig(config: BwConfig): Promise<void>;
 export declare function clearConfig(): Promise<void>;

package/dist/hooks/bw.js

@@ -4,7 +4,34 @@ import path from "path";
 import { CipherType, Client } from "../clients/bw.js";
 import { useCallback, useEffect, useState } from "react";
 export const bwClient = new Client();
-const configPath = path.join(os.homedir(), ".config", "bitty", "config.json");
+const configDir = path.join(os.homedir(), ".config", "bitty");
+const configPath = path.join(configDir, "config.json");
+export async function loadLoginHints() {
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = await fs.promises.readFile(configPath, "utf-8");
+            const config = JSON.parse(Buffer.from(content, "base64").toString("utf-8"));
+            return { email: config.email, baseUrl: config.baseUrl };
+        }
+    }
+    catch { }
+    return {};
+}
+export async function saveLoginHints(hints) {
+    let config = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = await fs.promises.readFile(configPath, "utf-8");
+            config = JSON.parse(Buffer.from(content, "base64").toString("utf-8"));
+        }
+    }
+    catch { }
+    config.email = hints.email;
+    config.baseUrl = hints.baseUrl;
+    const encoded = Buffer.from(JSON.stringify(config)).toString("base64");
+    await fs.promises.mkdir(configDir, { recursive: true });
+    await fs.promises.writeFile(configPath, encoded);
+}
 export async function loadConfig() {
     try {
         if (fs.existsSync(configPath)) {
@@ -15,8 +42,6 @@ export async function loadConfig() {
             }
             if (config.keys && config.refreshToken) {
                 const keys = {};
-                if (config.keys.masterKey)
-                    keys.masterKey = Uint8Array.from(config.keys.masterKey);
                 if (config.keys.masterPasswordHash)
                     keys.masterPasswordHash = config.keys.masterPasswordHash;
                 if (config.keys.privateKey)
@@ -50,8 +75,6 @@ export async function loadConfig() {
 }
 export async function saveConfig(config) {
     const keys = {};
-    if (config.keys.masterKey)
-        keys.masterKey = Array.from(config.keys.masterKey);
     if (config.keys.masterPasswordHash)
         keys.masterPasswordHash = config.keys.masterPasswordHash;
     if (config.keys.privateKey)
@@ -73,7 +96,7 @@ export async function saveConfig(config) {
         ...config,
         keys,
     })).toString("base64");
-    await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.promises.mkdir(configDir, { recursive: true });
     await fs.promises.writeFile(configPath, encConfig);
 }
 export async function clearConfig() {

package/dist/login/LoginView.js

@@ -4,7 +4,7 @@ import { useEffect, useState } from "react";
 import { TextInput } from "../components/TextInput.js";
 import { Button } from "../components/Button.js";
 import { primary } from "../theme/style.js";
-import { bwClient, loadConfig, saveConfig } from "../hooks/bw.js";
+import { bwClient, loadConfig, loadLoginHints, saveConfig, saveLoginHints } from "../hooks/bw.js";
 import { useStatusMessage } from "../hooks/status-message.js";
 import { Checkbox } from "../components/Checkbox.js";
 import { FetchError, TwoFactorProvider } from "../clients/bw.js";
@@ -94,6 +94,12 @@ export function LoginView({ onLogin }) {
                     refreshToken: bwClient.refreshToken,
                 });
             }
+            else {
+                saveLoginHints({
+                    email: email?.trim() || undefined,
+                    baseUrl: url?.trim() || undefined,
+                });
+            }
         }
         catch (e) {
             showStatusMessage("Login failed, please check your credentials.", "error");
@@ -105,7 +111,13 @@ export function LoginView({ onLogin }) {
                 const loggedIn = await loadConfig();
                 if (loggedIn) {
                     onLogin();
+                    return;
                 }
+                const hints = await loadLoginHints();
+                if (hints.baseUrl)
+                    setUrl(hints.baseUrl);
+                if (hints.email)
+                    setEmail(hints.email);
             }
             catch (e) {
                 showStatusMessage("Failed to load config file", "error");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitty-tui",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "license": "MIT",
   "repository": "https://github.com/mceck/bitty",
   "keywords": [

package/readme.md

@@ -3,7 +3,13 @@
 ## Install
 
 ```bash
-$ npm install -g bitty-tui
+npm install -g bitty-tui
+```
+
+Run with:
+
+```bash
+bitty
 ```
 
 ## Description
@@ -20,13 +26,13 @@ If you check "Remember me" during login, your vault encryption keys will be stor
 ## TODO
 
 - Collections support
-- Implement Fido, Duo MFA support
+- Test Fido, Duo MFA support
 - Handle more fields editing
 - Handle creating different cipher types
 
 ## Acknowledgments
-
-- [Bitwarden](https://github.com/bitwarden)
+- [Bitwarden whitepaper](https://bitwarden.com/help/bitwarden-security-white-paper)
+- [Bitwarden github](https://github.com/bitwarden)
 - [BitwardenDecrypt](https://github.com/GurpreetKang/BitwardenDecrypt)
 
 This project is not associated with [Bitwarden](https://github.com/bitwarden) or [Bitwarden, Inc.](https://bitwarden.com/)