bwx 0.2.0 → 0.2.2

package/README.md

@@ -70,6 +70,7 @@ bwx doctor
 |---------|-------------|
 | `bwx config email [addr]` | Set account email |
 | `bwx config master-password` | Store master password in Keychain |
+| `bwx config list` / `bwx cfg ls` | Show config path + redacted content |
 
 ### Global flags
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bwx",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "keywords": [
     "bitwarden",

package/src/cli/commands/config.ts

@@ -1,8 +1,12 @@
 import type { Command } from "commander";
 import { getGlobalOpts } from "../program.ts";
-import { emitSuccess } from "../io.ts";
+import { emitData, emitSuccess } from "../io.ts";
 import { CliError, ExitCode } from "../errors.ts";
-import { loadConfig, saveConfig } from "../../config/store.ts";
+import {
+	getConfigPath,
+	loadConfig,
+	saveConfig,
+} from "../../config/store.ts";
 
 export function registerConfig(program: Command): void {
 	const configCmd = program
@@ -90,6 +94,72 @@ export function registerConfig(program: Command): void {
 
 			emitSuccess("Master password saved to Keychain", opts);
 		});
+
+	configCmd
+		.command("list").alias("ls")
+		.description("Show config file path and redacted content")
+		.action(async function (this: Command) {
+			const opts = getGlobalOpts(this);
+			const path = getConfigPath();
+			const file = Bun.file(path);
+			const exists = await file.exists();
+			let config: unknown = null;
+
+			if (exists) {
+				try {
+					config = JSON.parse(await file.text());
+				} catch (err) {
+					throw new CliError(
+						`Config file is not valid JSON: ${
+							err instanceof Error ? err.message : String(err)
+						}`,
+						ExitCode.Config,
+					);
+				}
+			}
+
+			emitData(
+				{
+					path,
+					exists,
+					config: redactSensitive(config),
+				},
+				opts,
+			);
+		});
+}
+
+const SENSITIVE_KEY_RE = [
+	/pass(word)?/i,
+	/secret/i,
+	/token/i,
+	/api[-_]?key/i,
+	/private/i,
+	/credential/i,
+	/session/i,
+	/auth/i,
+	/totp/i,
+];
+
+function redactSensitive(value: unknown): unknown {
+	if (!value || typeof value !== "object") {
+		return value;
+	}
+
+	if (Array.isArray(value)) {
+		return value.map((item) => redactSensitive(item));
+	}
+
+	const out: Record<string, unknown> = {};
+	for (const [key, current] of Object.entries(value)) {
+		out[key] = isSensitiveKey(key) ? "***REDACTED***" : redactSensitive(current);
+	}
+
+	return out;
+}
+
+function isSensitiveKey(key: string): boolean {
+	return SENSITIVE_KEY_RE.some((pattern) => pattern.test(key));
 }
 
 async function readLine(): Promise<string> {

package/src/cli/commands/get.ts

@@ -1,47 +1,142 @@
 import type { Command } from "commander";
 import { getGlobalOpts } from "../program.ts";
 import { emitData } from "../io.ts";
-import { handleFatalError } from "../io.ts";
 import { CliError, ExitCode } from "../errors.ts";
 import { runBwOrThrow } from "../../bw/runner.ts";
 import { withSession } from "../../bw/session.ts";
+import { BW_TYPE_LABELS, BwItemSchema } from "../../bw/types.ts";
+import pc from "picocolors";
 
-const VALID_FIELDS = ["password", "username", "totp", "notes", "uri", "item"];
+const BUILTIN_FIELDS = ["password", "username", "totp", "notes", "uri", "item"];
 
 export function registerGet(program: Command): void {
 	program
 		.command("get")
-		.description("Get a field from a vault item")
-		.argument("<field>", `Field: ${VALID_FIELDS.join(" | ")}`)
+		.description("Get a field from a vault item (built-in or custom)")
+		.argument("<field>", "Field: password | username | totp | notes | uri | item | <custom>")
 		.argument("<item>", "Item name or ID")
 		.action(async function (this: Command, field: string, item: string) {
 			const opts = getGlobalOpts(this);
 
-			if (!VALID_FIELDS.includes(field)) {
-				throw new CliError(
-					`Invalid field "${field}". Valid: ${VALID_FIELDS.join(", ")}`,
-					ExitCode.BadArgs,
-				);
-			}
-
-			const result = await withSession(opts, async () => {
-				if (field === "item") {
-					return runBwOrThrow(["get", "item", item]);
-				}
-				return runBwOrThrow(["get", field, item]);
-			});
-
-			if (!result) {
-				throw new CliError(
-					`No ${field} found for item: ${item}`,
-					ExitCode.NotFound,
-				);
+			if (BUILTIN_FIELDS.includes(field)) {
+				await getBuiltinField(field, item, opts);
+			} else {
+				await getCustomField(field, item, opts);
 			}
+		});
+}
 
+async function getBuiltinField(
+	field: string,
+	item: string,
+	opts: ReturnType<typeof getGlobalOpts>,
+): Promise<void> {
+	try {
+		const result = await withSession(opts, async () => {
 			if (field === "item") {
-				emitData(JSON.parse(result), opts);
-			} else {
-				emitData(result, opts);
+				return runBwOrThrow(["get", "item", item]);
 			}
+			return runBwOrThrow(["get", field, item]);
 		});
+
+		if (!result) {
+			throw new CliError(
+				`No ${field} found for item: ${item}`,
+				ExitCode.NotFound,
+			);
+		}
+
+		if (field === "item") {
+			emitData(JSON.parse(result), opts);
+		} else {
+			emitData(result, opts);
+		}
+	} catch (err) {
+		if (
+			err instanceof CliError &&
+			/more than one result/i.test(err.message)
+		) {
+			const matches = await resolveAmbiguous(item);
+			throw new CliError(
+				formatAmbiguousError(item, matches, opts),
+				ExitCode.BadArgs,
+			);
+		}
+		throw err;
+	}
+}
+
+async function getCustomField(
+	fieldName: string,
+	item: string,
+	opts: ReturnType<typeof getGlobalOpts>,
+): Promise<void> {
+	const json = await withSession(opts, () =>
+		runBwOrThrow(["get", "item", item]),
+	);
+
+	const parsed = BwItemSchema.parse(JSON.parse(json));
+	const fields = parsed.fields ?? [];
+	const match = fields.find((f) => f.name === fieldName);
+
+	if (!match) {
+		const available = fields.map((f) => f.name).join(", ");
+		const msg = available
+			? `Field "${fieldName}" not found. Available: ${available}`
+			: `Field "${fieldName}" not found (item has no custom fields)`;
+		throw new CliError(msg, ExitCode.NotFound);
+	}
+
+	emitData(match.value ?? "", opts);
+}
+
+interface MatchInfo {
+	id: string;
+	name: string;
+	type: string;
+	username?: string;
+}
+
+async function resolveAmbiguous(query: string): Promise<MatchInfo[]> {
+	try {
+		const json = await runBwOrThrow([
+			"list",
+			"items",
+			"--search",
+			query,
+		]);
+		const items: Array<Record<string, unknown>> = JSON.parse(json);
+		return items.map((i) => ({
+			id: i.id as string,
+			name: i.name as string,
+			type: BW_TYPE_LABELS[i.type as number] ?? `type:${i.type}`,
+			username: (i.login as Record<string, unknown> | null)?.username as
+				| string
+				| undefined,
+		}));
+	} catch {
+		return [];
+	}
+}
+
+function formatAmbiguousError(
+	query: string,
+	matches: MatchInfo[],
+	opts: { json?: boolean },
+): string {
+	if (matches.length === 0) {
+		return `Multiple items match "${query}". Use a specific ID instead.`;
+	}
+
+	if (opts.json) {
+		return `Multiple items match "${query}": ${JSON.stringify(matches)}`;
+	}
+
+	const lines = [`Multiple items match "${query}":\n`];
+	for (const m of matches) {
+		const user = m.username ? ` (${m.username})` : "";
+		lines.push(`  ${pc.dim(m.id)}  ${pc.cyan(m.type)}  ${m.name}${pc.dim(user)}`);
+	}
+	lines.push(`\nUse a specific ID: ${pc.dim("bwx get <field> <id>")}`);
+	return lines.join("\n");
 }

package/src/cli/program.ts

@@ -1,7 +1,6 @@
 import { Command } from "commander";
 import type { GlobalOptions } from "./types.ts";
 import { registerGet } from "./commands/get.ts";
-import { registerField } from "./commands/field.ts";
 import { registerSearch } from "./commands/search.ts";
 import { registerCreate } from "./commands/create.ts";
 import { registerEdit } from "./commands/edit.ts";
@@ -20,7 +19,7 @@ export function buildProgram(): Command {
 	program
 		.name("bwx")
 		.description("Bitwarden Extended CLI")
-		.version("0.2.0")
+		.version("0.2.2")
 		.option("--json", "JSON output")
 		.option("--plain", "Plain parseable output")
 		.option("-q, --quiet", "Suppress log output")
@@ -35,7 +34,6 @@ export function buildProgram(): Command {
 	registerUnlock(program);
 	registerLock(program);
 	registerGet(program);
-	registerField(program);
 	registerSearch(program);
 	registerSync(program);
 	registerCreate(program);

package/src/config/store.ts

@@ -4,6 +4,10 @@ const CONFIG_DIR =
 	process.env.XDG_CONFIG_HOME ?? `${process.env.HOME}/.config`;
 const CONFIG_PATH = `${CONFIG_DIR}/bwx/config.json`;
 
+export function getConfigPath(): string {
+	return CONFIG_PATH;
+}
+
 export async function loadConfig(): Promise<Config> {
 	try {
 		const text = await Bun.file(CONFIG_PATH).text();

package/src/index.ts

@@ -7,6 +7,12 @@ import type { GlobalOptions } from "./cli/types.ts";
 export async function main(argv: string[]): Promise<void> {
 	const program = buildProgram();
 
+	// Bare invocation should show top-level help.
+	if (argv.length <= 2) {
+		program.outputHelp();
+		return;
+	}
+
 	// Parse global opts early for error formatting
 	let opts: GlobalOptions = {};
 	try {
@@ -26,6 +32,22 @@ export async function main(argv: string[]): Promise<void> {
 		await program.parseAsync(argv);
 	} catch (err) {
 		if (err instanceof CommanderError) {
+			if (err.code === "commander.help") {
+				const helpArgv = [...argv, "--help"];
+				try {
+					await program.parseAsync(helpArgv);
+				} catch (helpErr) {
+					if (
+						!(
+							helpErr instanceof CommanderError &&
+							helpErr.code === "commander.helpDisplayed"
+						)
+					) {
+						throw helpErr;
+					}
+				}
+				process.exit(err.exitCode);
+			}
 			if (err.exitCode === 0) process.exit(0); // --help, --version
 			// Commander prefixes messages with "error: " — strip it
 			const msg = err.message.replace(/^error:\s*/i, "");

package/src/cli/commands/field.ts

@@ -1,36 +0,0 @@
-import type { Command } from "commander";
-import { getGlobalOpts } from "../program.ts";
-import { emitData } from "../io.ts";
-import { CliError, ExitCode } from "../errors.ts";
-import { runBwOrThrow } from "../../bw/runner.ts";
-import { withSession } from "../../bw/session.ts";
-import { BwItemSchema } from "../../bw/types.ts";
-
-export function registerField(program: Command): void {
-	program
-		.command("field")
-		.description("Get a custom field from a vault item")
-		.argument("<item>", "Item name or ID")
-		.argument("<field-name>", "Custom field name")
-		.action(async function (this: Command, item: string, fieldName: string) {
-			const opts = getGlobalOpts(this);
-
-			const json = await withSession(opts, () =>
-				runBwOrThrow(["get", "item", item]),
-			);
-
-			const parsed = BwItemSchema.parse(JSON.parse(json));
-			const fields = parsed.fields ?? [];
-			const match = fields.find((f) => f.name === fieldName);
-
-			if (!match) {
-				const available = fields.map((f) => f.name).join(", ");
-				const msg = available
-					? `Field "${fieldName}" not found. Available: ${available}`
-					: `Field "${fieldName}" not found (item has no custom fields)`;
-				throw new CliError(msg, ExitCode.NotFound);
-			}
-
-			emitData(match.value ?? "", opts);
-		});
-}