bwx 0.1.0

package/src/cli/io.ts

@@ -0,0 +1,72 @@
+import pc from "picocolors";
+import { CliError, ExitCode } from "./errors.ts";
+import type { GlobalOptions } from "./types.ts";
+
+export function emitData(value: unknown, opts: GlobalOptions): void {
+	if (opts.json) {
+		process.stdout.write(JSON.stringify({ data: value }, null, 2) + "\n");
+	} else if (opts.plain) {
+		if (typeof value === "string") {
+			process.stdout.write(value + "\n");
+		} else if (Array.isArray(value)) {
+			for (const item of value) {
+				process.stdout.write(String(item) + "\n");
+			}
+		} else {
+			process.stdout.write(JSON.stringify(value) + "\n");
+		}
+	} else {
+		if (typeof value === "string") {
+			process.stdout.write(value + "\n");
+		} else {
+			process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+		}
+	}
+}
+
+export function emitLog(message: string, opts: GlobalOptions): void {
+	if (opts.quiet || opts.json) return;
+	process.stderr.write(message + "\n");
+}
+
+export function emitSuccess(message: string, opts: GlobalOptions): void {
+	if (opts.quiet || opts.json) return;
+	process.stderr.write(pc.green("✓") + " " + message + "\n");
+}
+
+export function emitWarn(message: string, opts: GlobalOptions): void {
+	if (opts.quiet || opts.json) return;
+	process.stderr.write(pc.yellow("⚠") + " " + message + "\n");
+}
+
+export function handleFatalError(err: unknown, opts: GlobalOptions): never {
+	const cliErr =
+		err instanceof CliError
+			? err
+			: new CliError(
+					err instanceof Error ? err.message : String(err),
+					ExitCode.Unknown,
+				);
+
+	if (opts.json) {
+		process.stdout.write(
+			JSON.stringify(
+				{
+					error: {
+						message: cliErr.message,
+						exitCode: cliErr.exitCode,
+					},
+				},
+				null,
+				2,
+			) + "\n",
+		);
+	} else {
+		process.stderr.write(pc.red("error:") + " " + cliErr.message + "\n");
+		if (opts.verbose && cliErr.stack) {
+			process.stderr.write(pc.dim(cliErr.stack) + "\n");
+		}
+	}
+
+	process.exit(cliErr.exitCode);
+}

package/src/cli/program.ts

@@ -0,0 +1,55 @@
+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";
+import { registerDelete } from "./commands/delete.ts";
+import { registerStatus } from "./commands/status.ts";
+import { registerSync } from "./commands/sync.ts";
+import { registerUnlock } from "./commands/unlock.ts";
+import { registerLock } from "./commands/lock.ts";
+import { registerConfig } from "./commands/config.ts";
+
+export function buildProgram(): Command {
+	const program = new Command();
+
+	program
+		.name("bwx")
+		.description("Bitwarden Extended CLI")
+		.version("0.1.0")
+		.option("--json", "JSON output")
+		.option("--plain", "Plain parseable output")
+		.option("-q, --quiet", "Suppress log output")
+		.option("-v, --verbose", "Verbose output")
+		.exitOverride()
+		.configureOutput({
+			writeOut: (str) => process.stdout.write(str),
+			writeErr: () => {}, // silenced — we handle all errors in main()
+		});
+
+	registerStatus(program);
+	registerUnlock(program);
+	registerLock(program);
+	registerGet(program);
+	registerField(program);
+	registerSearch(program);
+	registerSync(program);
+	registerCreate(program);
+	registerEdit(program);
+	registerDelete(program);
+	registerConfig(program);
+
+	return program;
+}
+
+export function getGlobalOpts(cmd: Command): GlobalOptions {
+	const root = cmd.optsWithGlobals();
+	return {
+		json: root.json ?? false,
+		plain: root.plain ?? false,
+		quiet: root.quiet ?? false,
+		verbose: root.verbose ?? false,
+	};
+}

package/src/cli/types.ts

@@ -0,0 +1,10 @@
+export interface GlobalOptions {
+	json?: boolean;
+	plain?: boolean;
+	quiet?: boolean;
+	verbose?: boolean;
+}
+
+export interface CliContext {
+	opts: GlobalOptions;
+}

package/src/config/schema.ts

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+
+export const ConfigSchema = z.object({
+	email: z.string().optional(),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;

package/src/config/store.ts

@@ -0,0 +1,21 @@
+import { ConfigSchema, type Config } from "./schema.ts";
+
+const CONFIG_DIR =
+	process.env.XDG_CONFIG_HOME ?? `${process.env.HOME}/.config`;
+const CONFIG_PATH = `${CONFIG_DIR}/bwx/config.json`;
+
+export async function loadConfig(): Promise<Config> {
+	try {
+		const text = await Bun.file(CONFIG_PATH).text();
+		return ConfigSchema.parse(JSON.parse(text));
+	} catch {
+		return ConfigSchema.parse({});
+	}
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+	const dir = CONFIG_PATH.replace(/\/[^/]+$/, "");
+	const { mkdirSync } = await import("node:fs");
+	mkdirSync(dir, { recursive: true });
+	await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+import { CommanderError } from "commander";
+import { buildProgram } from "./cli/program.ts";
+import { handleFatalError } from "./cli/io.ts";
+import { CliError, ExitCode } from "./cli/errors.ts";
+import type { GlobalOptions } from "./cli/types.ts";
+
+export async function main(argv: string[]): Promise<void> {
+	const program = buildProgram();
+
+	// Parse global opts early for error formatting
+	let opts: GlobalOptions = {};
+	try {
+		program.parseOptions(argv.slice(2));
+		const rawOpts = program.opts();
+		opts = {
+			json: rawOpts.json ?? false,
+			plain: rawOpts.plain ?? false,
+			quiet: rawOpts.quiet ?? false,
+			verbose: rawOpts.verbose ?? false,
+		};
+	} catch {
+		// Fall through — full parse below will handle
+	}
+
+	try {
+		await program.parseAsync(argv);
+	} catch (err) {
+		if (err instanceof CommanderError) {
+			if (err.exitCode === 0) process.exit(0); // --help, --version
+			// Commander prefixes messages with "error: " — strip it
+			const msg = err.message.replace(/^error:\s*/i, "");
+			handleFatalError(new CliError(msg, ExitCode.BadArgs), opts);
+		}
+		handleFatalError(err, opts);
+	}
+}