@cuytamvan/cuypwm 1.0.0

package/src/keys.ts

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import {
+  PRIVATE_KEY_PATH,
+  PUBLIC_KEY_PATH,
+  CONFIG_FILE,
+  ensureAppDir,
+} from './config';
+import type { AppConfig } from './types';
+
+export function keysExist(): boolean {
+  return existsSync(PRIVATE_KEY_PATH) && existsSync(PUBLIC_KEY_PATH);
+}
+
+export function loadConfig(): AppConfig {
+  if (!existsSync(CONFIG_FILE)) return { protected: false };
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return { protected: false };
+  }
+}
+
+export function saveConfig(cfg: AppConfig) {
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+
+async function runOpenssl(args: string[], env?: Record<string, string>) {
+  const proc = Bun.spawn(['openssl', ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: { ...process.env, ...env },
+  });
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`openssl exited with code ${exitCode}: ${stderr.trim()}`);
+  }
+}
+
+export async function generateKeysFlow() {
+  ensureAppDir();
+
+  p.log.warn(
+    chalk.yellow('Key pair not found at ~/.cuy-pwm/keys. Generating one now.'),
+  );
+
+  const useProtect = await p.confirm({
+    message: 'Protect private key with a passphrase?',
+    initialValue: true,
+  });
+
+  if (p.isCancel(useProtect)) {
+    p.cancel('Cancelled.');
+    process.exit(0);
+  }
+
+  let passphrase: string | undefined;
+
+  if (useProtect) {
+    const pass1 = await p.password({ message: 'Enter passphrase' });
+    if (p.isCancel(pass1)) {
+      p.cancel('Cancelled.');
+      process.exit(0);
+    }
+
+    const pass2 = await p.password({ message: 'Confirm passphrase' });
+    if (p.isCancel(pass2)) {
+      p.cancel('Cancelled.');
+      process.exit(0);
+    }
+
+    if (pass1 !== pass2) {
+      p.log.error(
+        chalk.red('Passphrases do not match. Please restart the application.'),
+      );
+      process.exit(1);
+    }
+
+    passphrase = pass1;
+  }
+
+  const s = p.spinner();
+  s.start('Generating RSA 4096-bit key pair via openssl...');
+
+  try {
+    if (passphrase) {
+      await runOpenssl(
+        [
+          'genrsa',
+          '-aes256',
+          '-passout',
+          'env:PWM_PASSPHRASE',
+          '-out',
+          PRIVATE_KEY_PATH,
+          '4096',
+        ],
+        { PWM_PASSPHRASE: passphrase },
+      );
+
+      await runOpenssl(
+        [
+          'rsa',
+          '-in',
+          PRIVATE_KEY_PATH,
+          '-passin',
+          'env:PWM_PASSPHRASE',
+          '-pubout',
+          '-out',
+          PUBLIC_KEY_PATH,
+        ],
+        { PWM_PASSPHRASE: passphrase },
+      );
+    } else {
+      await runOpenssl(['genrsa', '-out', PRIVATE_KEY_PATH, '4096']);
+      await runOpenssl([
+        'rsa',
+        '-in',
+        PRIVATE_KEY_PATH,
+        '-pubout',
+        '-out',
+        PUBLIC_KEY_PATH,
+      ]);
+    }
+
+    saveConfig({ protected: !!passphrase });
+
+    s.stop('RSA key pair generated successfully.');
+    p.log.success(chalk.green(`Private key: ${PRIVATE_KEY_PATH}`));
+    p.log.success(chalk.green(`Public key : ${PUBLIC_KEY_PATH}`));
+  } catch (err) {
+    s.stop('Failed to generate key.');
+    p.log.error(chalk.red(String(err)));
+    process.exit(1);
+  }
+}
+
+export async function ensureKeys() {
+  if (!keysExist()) {
+    await generateKeysFlow();
+  }
+}
+
+export function readPublicKey(): string {
+  return readFileSync(PUBLIC_KEY_PATH, 'utf8');
+}
+
+export function readPrivateKeyPem(): string {
+  return readFileSync(PRIVATE_KEY_PATH, 'utf8');
+}
+
+export async function getPrivateKeyPassphraseIfNeeded(): Promise<
+  string | undefined
+> {
+  const cfg = loadConfig();
+  if (!cfg.protected) return undefined;
+
+  const pass = await p.password({ message: 'Enter private key passphrase' });
+  if (p.isCancel(pass)) {
+    p.cancel('Cancelled.');
+    process.exit(0);
+  }
+  return pass;
+}

package/src/store.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { SOURCE_FILE, ensureAppDir } from './config';
+import type { PasswordEntry, CredUser } from './types';
+
+interface DbStore {
+  cred_users: CredUser[];
+  cred_entries: PasswordEntry[];
+}
+
+function loadDb(): DbStore {
+  ensureAppDir();
+  if (!existsSync(SOURCE_FILE)) return { cred_users: [], cred_entries: [] };
+  try {
+    return JSON.parse(readFileSync(SOURCE_FILE, 'utf8'));
+  } catch {
+    return { cred_users: [], cred_entries: [] };
+  }
+}
+
+function saveDb(db: DbStore) {
+  ensureAppDir();
+  writeFileSync(SOURCE_FILE, JSON.stringify(db, null, 2));
+}
+
+export function loadEntries(): PasswordEntry[] {
+  return loadDb().cred_entries;
+}
+
+export function addEntry(entry: PasswordEntry) {
+  const db = loadDb();
+  db.cred_entries.push(entry);
+  saveDb(db);
+}
+
+export function deleteEntry(id: string) {
+  const db = loadDb();
+  db.cred_entries = db.cred_entries.filter((e) => e.id !== id);
+  saveDb(db);
+}
+
+export function updateEntry(updated: PasswordEntry) {
+  const db = loadDb();
+  db.cred_entries = db.cred_entries.map((e) =>
+    e.id === updated.id ? updated : e,
+  );
+  saveDb(db);
+}
+
+export function loadUsers(): CredUser[] {
+  return loadDb().cred_users;
+}
+
+export function addUser(user: CredUser) {
+  const db = loadDb();
+  db.cred_users.push(user);
+  saveDb(db);
+}
+
+export function updateUser(updated: CredUser) {
+  const db = loadDb();
+  db.cred_users = db.cred_users.map((u) => (u.id === updated.id ? updated : u));
+  saveDb(db);
+}
+
+export function deleteUser(id: string) {
+  const db = loadDb();
+  db.cred_users = db.cred_users.filter((u) => u.id !== id);
+  saveDb(db);
+}
+
+export function newId(): string {
+  return randomUUID();
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+export type CredentialType =
+  'github' | 'gitlab' | 'gmail' | 'bank' | 'website' | 'ssh_cred' | 'ssh_key';
+
+export interface CredUser {
+  id: string;
+  name: string;
+}
+
+export interface BaseEntry {
+  id: string;
+  type: CredentialType;
+  source: string;
+  description: string;
+  createdAt: string;
+  cred_user_id: string | null;
+}
+
+export interface SimpleCredentialEntry extends BaseEntry {
+  type: 'github' | 'gitlab' | 'gmail' | 'website' | 'bank';
+  username: string;
+  encrypted_password: string;
+  extra?: Record<string, string>;
+}
+
+export interface SshCredEntry extends BaseEntry {
+  type: 'ssh_cred';
+  username: string;
+  encrypted_password: string;
+  host: string;
+  port: number;
+}
+
+export interface SshKeyEntry extends BaseEntry {
+  type: 'ssh_key';
+  encrypted_private_key: string;
+  public_key: string;
+}
+
+export type PasswordEntry = SimpleCredentialEntry | SshCredEntry | SshKeyEntry;
+
+export interface AppConfig {
+  protected: boolean;
+}

package/src/ui.ts

@@ -0,0 +1,212 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import type { PasswordEntry, CredentialType, CredUser } from './types';
+
+function hexToRgb(hex: string): [number, number, number] {
+  const clean = hex.replace('#', '');
+  const num = parseInt(clean, 16);
+  return [(num >> 16) & 255, (num >> 8) & 255, num & 255];
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return Math.round(a + (b - a) * t);
+}
+
+function gradientText(text: string, fromHex: string, toHex: string): string {
+  const [r1, g1, b1] = hexToRgb(fromHex);
+  const [r2, g2, b2] = hexToRgb(toHex);
+  const chars = [...text];
+
+  return chars
+    .map((ch, i) => {
+      if (ch === ' ') return ch;
+      const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+      const r = lerp(r1, r2, t);
+      const g = lerp(g1, g2, t);
+      const b = lerp(b1, b2, t);
+      return chalk.rgb(r, g, b)(ch);
+    })
+    .join('');
+}
+
+const LOGO_LINES = [
+  ' ██████╗██╗   ██╗██╗   ██╗      ██████╗ ██╗    ██╗███╗   ███╗',
+  '██╔════╝██║   ██║╚██╗ ██╔╝      ██╔══██╗██║    ██║████╗ ████║',
+  '██║     ██║   ██║ ╚████╔╝ █████╗██████╔╝██║ █╗ ██║██╔████╔██║',
+  '██║     ██║   ██║  ╚██╔╝  ╚════╝██╔═══╝ ██║███╗██║██║╚██╔╝██║',
+  '╚██████╗╚██████╔╝   ██║         ██║     ╚███╔███╔╝██║ ╚═╝ ██║',
+  ' ╚═════╝ ╚═════╝    ╚═╝         ╚═╝      ╚══╝╚══╝ ╚═╝     ╚═╝',
+];
+
+export function printBanner() {
+  console.clear();
+
+  const logo = LOGO_LINES.map((line) =>
+    gradientText(line, '#22d3ee', '#c084fc'),
+  ).join('\n');
+
+  console.log();
+  console.log(logo);
+  console.log(
+    chalk.dim('    🔐 CLI Password Manager  •  powered by Bun & OpenSSL'),
+  );
+  console.log(chalk.dim('               copyright by cuytamvan 2026'));
+  console.log(
+    chalk.dim('  ────────────────────────────────────────────────────────'),
+  );
+  console.log();
+}
+
+export function divider() {
+  console.log(
+    chalk.dim('────────────────────────────────────────────────────────'),
+  );
+}
+
+export function pressEnterHint() {
+  return chalk.dim.italic('Press Enter to return to the menu...');
+}
+
+export const TYPE_META: Record<
+  CredentialType,
+  { icon: string; label: string; color: string }
+> = {
+  github: { icon: '🐙', label: 'GitHub', color: '#e6edf3' },
+  gitlab: { icon: '🦊', label: 'GitLab', color: '#fc6d26' },
+  gmail: { icon: '✉️ ', label: 'Gmail', color: '#ea4335' },
+  bank: { icon: '🏦', label: 'Bank Account', color: '#facc15' },
+  website: { icon: '🌐', label: 'Website', color: '#38bdf8' },
+  ssh_cred: { icon: '🖥️ ', label: 'SSH Credential', color: '#34d399' },
+  ssh_key: { icon: '🔑', label: 'SSH Key', color: '#a78bfa' },
+};
+
+export function typeBadge(type: CredentialType): string {
+  const meta = TYPE_META[type];
+  return chalk.hex(meta.color).bold(`${meta.icon} ${meta.label}`);
+}
+
+export function entryLabel(e: PasswordEntry): string {
+  const desc = e.description ? chalk.dim(` — ${e.description}`) : '';
+  return `${typeBadge(e.type)}  ${chalk.whiteBright(e.source)}${desc}`;
+}
+
+export function credentialTypeOptions() {
+  return (Object.keys(TYPE_META) as CredentialType[]).map((type) => ({
+    value: type,
+    label: typeBadge(type),
+  }));
+}
+
+export function detailBox(entry: PasswordEntry, body: string): string {
+  const meta = TYPE_META[entry.type];
+  return boxen(body, {
+    title: `${meta.icon} ${entry.source}`,
+    titleAlignment: 'center',
+    padding: 1,
+    margin: { top: 1, bottom: 1, left: 0, right: 0 },
+    borderStyle: 'round',
+    borderColor: meta.color,
+  });
+}
+
+export function passwordBox(password: string, title = '🎲 Password'): string {
+  return boxen(chalk.bold.hex('#facc15')(password), {
+    title,
+    titleAlignment: 'center',
+    padding: 1,
+    margin: { top: 1, bottom: 1, left: 0, right: 0 },
+    borderStyle: 'double',
+    borderColor: 'yellow',
+  });
+}
+
+export function dangerBox(title: string, body: string): string {
+  return boxen(body, {
+    title,
+    titleAlignment: 'center',
+    padding: 1,
+    margin: { top: 1, bottom: 1, left: 0, right: 0 },
+    borderStyle: 'round',
+    borderColor: 'red',
+  });
+}
+
+export function successBox(title: string, body: string): string {
+  return boxen(body, {
+    title,
+    titleAlignment: 'center',
+    padding: 1,
+    margin: { top: 1, bottom: 1, left: 0, right: 0 },
+    borderStyle: 'round',
+    borderColor: 'green',
+  });
+}
+
+function truncate(text: string, max: number): string {
+  if (!text) return chalk.dim('-');
+  return text.length > max ? text.slice(0, max - 1) + '…' : text;
+}
+
+function entryUsernameCol(e: PasswordEntry): string {
+  if (e.type === 'ssh_key') return chalk.dim('(key pair)');
+  if (e.type === 'ssh_cred')
+    return `${e.username}${chalk.dim('@' + e.host + ':' + e.port)}`;
+  return e.username;
+}
+
+export function entriesTable(
+  entries: PasswordEntry[],
+  users?: CredUser[],
+  showId: boolean = true,
+): string {
+  const userMap = new Map((users ?? []).map((u) => [u.id, u.name]));
+  const showUser = users !== undefined;
+
+  const head = [
+    ...(showId ? [chalk.bold.cyan('ID')] : []),
+    chalk.bold.cyan('Type'),
+    chalk.bold.cyan('Source'),
+    chalk.bold.cyan('Username / Info'),
+    chalk.bold.cyan('Description'),
+    chalk.bold.cyan('Created'),
+  ];
+  if (showUser) head.push(chalk.bold.cyan('User'));
+
+  const table = new Table({
+    head,
+    style: { head: [], border: ['dim'] },
+    wordWrap: true,
+  });
+
+  entries.forEach((e) => {
+    const meta = TYPE_META[e.type];
+    const typeCol = chalk.hex(meta.color).bold(`${meta.icon} ${meta.label}`);
+    const createdCol = chalk.dim(
+      new Date(e.createdAt).toLocaleDateString('id-ID', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+      }),
+    );
+
+    const row = [
+      ...(showId ? [chalk.whiteBright(e.id)] : []),
+      typeCol,
+      chalk.whiteBright(truncate(e.source, 24)),
+      entryUsernameCol(e),
+      truncate(e.description, 28),
+      createdCol,
+    ];
+    if (showUser) {
+      const userName = e.cred_user_id
+        ? (userMap.get(e.cred_user_id) ?? chalk.dim('?'))
+        : chalk.dim('-');
+      row.push(chalk.whiteBright(userName));
+    }
+    table.push(row);
+  });
+
+  const header = chalk.dim(`📋 Total: ${entries.length} credential(s) saved\n`);
+  return header + table.toString();
+}

package/src/utils/checkCancel.ts

@@ -0,0 +1,10 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+
+export function checkCancel<T>(value: T | symbol): T {
+  if (p.isCancel(value)) {
+    p.cancel(chalk.red('Cancelled.'));
+    process.exit(0);
+  }
+  return value as T;
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export { checkCancel } from './checkCancel';
+export { resolvePath } from './resolvePath';
+export { passwordOrGenerate } from './passwordOrGenerate';
+export { pickFilteredEntries } from './userFilter';
+export type { FilteredEntries } from './userFilter';

package/src/utils/passwordOrGenerate.ts

@@ -0,0 +1,31 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { promptGeneratePassword } from '../generator';
+import { passwordBox } from '../ui';
+import { checkCancel } from './checkCancel';
+
+export async function passwordOrGenerate(): Promise<string> {
+  const choice = checkCancel(
+    await p.select({
+      message: 'How would you like to set the password?',
+      options: [
+        { value: 'manual', label: `${chalk.blue('⌨️ ')}  Enter manually` },
+        { value: 'generate', label: `${chalk.yellow('🎲')} Generate password` },
+      ],
+    }),
+  );
+
+  if (choice === 'generate') {
+    const generated = await promptGeneratePassword();
+    if (!generated) {
+      p.log.warn(
+        chalk.yellow('Generation cancelled, falling back to manual input.'),
+      );
+      return checkCancel(await p.password({ message: 'Password' }));
+    }
+    console.log(passwordBox(generated, '🎲 Generated password'));
+    return generated;
+  }
+
+  return checkCancel(await p.password({ message: 'Password' }));
+}

package/src/utils/resolvePath.ts

@@ -0,0 +1,6 @@
+export function resolvePath(path: string): string {
+  if (path.startsWith('~')) {
+    return path.replace('~', process.env.HOME || process.env.USERPROFILE || '');
+  }
+  return path;
+}

package/src/utils/userFilter.ts

@@ -0,0 +1,37 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadEntries, loadUsers } from '../store';
+import type { PasswordEntry, CredUser } from '../types';
+import { checkCancel } from './checkCancel';
+
+export interface FilteredEntries {
+  /** Entries after applying the user filter (may equal allEntries if no filter). */
+  entries: PasswordEntry[];
+  users: CredUser[];
+  /** Total entries before filtering — used to differentiate "no data" vs "empty filter". */
+  total: number;
+}
+
+export async function pickFilteredEntries(): Promise<FilteredEntries> {
+  const allEntries = loadEntries();
+  const users = loadUsers();
+  let entries = allEntries;
+
+  if (users.length) {
+    const filterChoice = checkCancel(
+      await p.select({
+        message: 'Filter by user',
+        options: [
+          { value: '__all__', label: chalk.dim('All Users') },
+          ...users.map((u) => ({ value: u.id, label: u.name })),
+        ],
+      }),
+    ) as string;
+
+    if (filterChoice !== '__all__') {
+      entries = allEntries.filter((e) => e.cred_user_id === filterChoice);
+    }
+  }
+
+  return { entries, users, total: allEntries.length };
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}