@cuytamvan/cuypwm 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@cuytamvan/cuypwm",
+  "version": "1.0.0",
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "cuypwm": "dist/cuypwm.js"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run src/index.ts --watch",
+    "build": "bun build ./src/index.ts --compile --outfile=./dist/cuypwm",
+    "build:node": "bun build ./src/index.ts --outfile=./dist/cuypwm.js --target=node",
+    "pretty": "prettier --write src/**/*.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.9.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,249 @@
+import chalk from 'chalk';
+import { loadEntries, loadUsers } from './store';
+import { readPrivateKeyPem, getPrivateKeyPassphraseIfNeeded } from './keys';
+import { decryptData } from './crypto';
+import { entriesTable, TYPE_META } from './ui';
+import type { PasswordEntry, CredentialType } from './types';
+
+function showHelp() {
+  const T = chalk.bold.cyan;
+  const D = chalk.dim;
+  const types = Object.keys(TYPE_META).join(', ');
+  console.log(`
+${T('cuypwm')} — CLI Password Manager
+${D('powered by Bun & OpenSSL')}
+
+${chalk.bold('Usage:')}
+  cuypwm                           Launch interactive TUI
+  cuypwm -h                        Show this help
+
+${chalk.bold('Commands:')}
+  ${T('cuypwm ls')}
+    List all credentials (table view).
+
+  ${T('cuypwm get')} ${chalk.yellow('<cred_id>')}
+    Show credential detail without decrypting password.
+
+  ${T('cuypwm get')} ${chalk.yellow('<cred_id>')} ${chalk.green('--copy-password')}
+    Decrypt and copy password to clipboard (macOS / Linux).
+
+  ${T('cuypwm search')} ${chalk.yellow('<query>')}
+    Search across source, username, host, port, description.
+
+  ${T('cuypwm search')} ${chalk.green('--type')} ${chalk.yellow('<type>')}
+    Filter by credential type.
+    Available types: ${D(types)}
+
+  ${T('cuypwm search')} ${chalk.yellow('<query>')} ${chalk.green('--type')} ${chalk.yellow('<type>')}
+    Combine text search and type filter.
+`);
+}
+
+async function copyToClipboard(text: string): Promise<void> {
+  let cmd: string[];
+  if (process.platform === 'darwin') {
+    cmd = ['pbcopy'];
+  } else {
+    // try xclip, fallback to xsel
+    const which = Bun.spawnSync(['which', 'xclip']);
+    cmd =
+      which.exitCode === 0
+        ? ['xclip', '-selection', 'clipboard']
+        : ['xsel', '--clipboard', '--input'];
+  }
+  const proc = Bun.spawn(cmd, { stdin: 'pipe' });
+  proc.stdin!.write(text);
+  await proc.stdin!.end();
+  await proc.exited;
+}
+
+function matchEntry(entry: PasswordEntry, query: string): boolean {
+  const q = query.toLowerCase();
+  if (entry.source.toLowerCase().includes(q)) return true;
+  if (entry.description.toLowerCase().includes(q)) return true;
+  if (entry.type === 'ssh_cred') {
+    if (entry.username.toLowerCase().includes(q)) return true;
+    if (entry.host.toLowerCase().includes(q)) return true;
+    if (String(entry.port).includes(q)) return true;
+  }
+  if (entry.type !== 'ssh_key') {
+    if ((entry as { username: string }).username.toLowerCase().includes(q))
+      return true;
+  }
+  return false;
+}
+
+async function cmdLs(rest: string[]) {
+  const showIdFlag = rest.includes('--show-id');
+
+  const entries = loadEntries();
+  const users = loadUsers();
+  if (!entries.length) {
+    console.log(chalk.yellow('No credentials saved yet.'));
+    return;
+  }
+  console.log(entriesTable(entries, users, !!showIdFlag));
+}
+
+async function cmdGet(rest: string[]) {
+  const idArg = rest.find((a) => !a.startsWith('-'));
+  const copyFlag = rest.includes('--copy-password');
+  const showPrivateKeyFlag = rest.includes('--show-private-key');
+
+  if (!idArg) {
+    console.error(
+      chalk.red(
+        'Usage: cuypwm get <cred_id> [--copy-password] [--show-private-key]',
+      ),
+    );
+    process.exit(1);
+  }
+
+  const entries = loadEntries();
+  const users = loadUsers();
+  const entry = entries.find((e) => e.id === idArg);
+
+  if (!entry) {
+    console.error(chalk.red(`Credential with id '${idArg}' not found.`));
+    process.exit(1);
+  }
+
+  const userMap = new Map(users.map((u) => [u.id, u.name]));
+  const meta = TYPE_META[entry.type];
+
+  console.log();
+  console.log(
+    `  ${chalk.hex(meta.color).bold(`${meta.icon}  ${entry.source}`)}  ${chalk.dim(`[${entry.type}]`)}`,
+  );
+  console.log(`  ${chalk.dim('ID')}          : ${chalk.dim(entry.id)}`);
+  if (entry.cred_user_id) {
+    const userName = userMap.get(entry.cred_user_id) ?? chalk.dim('?');
+    console.log(
+      `  ${chalk.dim('User')}        : ${chalk.whiteBright(userName)}`,
+    );
+  }
+  console.log(
+    `  ${chalk.dim('Description')} : ${entry.description || chalk.dim('-')}`,
+  );
+
+  if (entry.type === 'ssh_key') {
+    console.log(
+      `  ${chalk.dim('Public Key')}  :\n${chalk.white(entry.public_key.trim())}`,
+    );
+    if (copyFlag) {
+      console.log(
+        chalk.yellow('\n  --copy-password is not applicable for SSH Keys.'),
+      );
+    }
+    if (showPrivateKeyFlag) {
+      const privateKey = await decryptEntry(entry.encrypted_private_key);
+      console.log(
+        `  ${chalk.dim('Private Key')} :\n${chalk.white(privateKey.trim())}`,
+      );
+    }
+  } else if (entry.type === 'ssh_cred') {
+    console.log(
+      `  ${chalk.dim('Host')}        : ${chalk.whiteBright(entry.host)}`,
+    );
+    console.log(
+      `  ${chalk.dim('Port')}        : ${chalk.whiteBright(String(entry.port))}`,
+    );
+    console.log(
+      `  ${chalk.dim('Username')}    : ${chalk.whiteBright(entry.username)}`,
+    );
+    console.log(
+      `  ${chalk.dim('Password')}    : ${chalk.dim('(encrypted — use --copy-password)')}`,
+    );
+    if (copyFlag) {
+      const pw = await decryptEntry(entry.encrypted_password);
+      await copyToClipboard(pw);
+      console.log(chalk.green('\n  ✔ Password copied to clipboard.'));
+    }
+  } else {
+    console.log(
+      `  ${chalk.dim('Username')}    : ${chalk.whiteBright(entry.username)}`,
+    );
+    console.log(
+      `  ${chalk.dim('Password')}    : ${chalk.dim('(encrypted — use --copy-password)')}`,
+    );
+    if (entry.extra) {
+      for (const [k, v] of Object.entries(entry.extra)) {
+        console.log(`  ${chalk.dim(k.padEnd(11))} : ${chalk.whiteBright(v)}`);
+      }
+    }
+    if (copyFlag) {
+      const pw = await decryptEntry(entry.encrypted_password);
+      await copyToClipboard(pw);
+      console.log(chalk.green('\n  ✔ Password copied to clipboard.'));
+    }
+  }
+  console.log();
+}
+
+async function decryptEntry(encryptedPassword: string): Promise<string> {
+  const privateKeyPem = readPrivateKeyPem();
+  const passphrase = await getPrivateKeyPassphraseIfNeeded();
+  return decryptData(privateKeyPem, passphrase, encryptedPassword);
+}
+
+async function cmdSearch(rest: string[]) {
+  const typeIdx = rest.indexOf('--type');
+  const typeFilter: CredentialType | undefined =
+    typeIdx !== -1 ? (rest[typeIdx + 1] as CredentialType) : undefined;
+
+  const queryTokens = rest.filter((a, i) => {
+    if (a.startsWith('-')) return false;
+    if (typeIdx !== -1 && i === typeIdx + 1) return false; // skip the type value
+    return true;
+  });
+  const query = queryTokens.join(' ').trim();
+
+  if (!query && !typeFilter) {
+    console.error(chalk.red('Usage: cuypwm search <query> [--type <type>]'));
+    process.exit(1);
+  }
+
+  const entries = loadEntries();
+  const users = loadUsers();
+  let results = entries;
+
+  if (typeFilter) {
+    results = results.filter((e) => e.type === typeFilter);
+  }
+  if (query) {
+    results = results.filter((e) => matchEntry(e, query));
+  }
+
+  if (!results.length) {
+    console.log(chalk.yellow('No matching results found.'));
+    return;
+  }
+
+  console.log(entriesTable(results, users));
+}
+
+export async function runCli(args: string[]): Promise<boolean> {
+  const [cmd, ...rest] = args;
+
+  if (cmd === '-h' || cmd === '--help') {
+    showHelp();
+    return true;
+  }
+
+  if (cmd === 'ls') {
+    await cmdLs(rest);
+    return true;
+  }
+
+  if (cmd === 'get') {
+    await cmdGet(rest);
+    return true;
+  }
+
+  if (cmd === 'search') {
+    await cmdSearch(rest);
+    return true;
+  }
+
+  return false;
+}

package/src/command-pages/addCredential.ts

@@ -0,0 +1,190 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+import { readPublicKey } from '../keys';
+import { encryptData } from '../crypto';
+import { loadUsers, addEntry, newId } from '../store';
+import { credentialTypeOptions } from '../ui';
+import { checkCancel, resolvePath, passwordOrGenerate } from '../utils';
+import type {
+  SimpleCredentialEntry,
+  SshCredEntry,
+  SshKeyEntry,
+  CredentialType,
+} from '../types';
+
+export async function addCredentialFlow() {
+  const type = checkCancel(
+    await p.select({
+      message: 'Select credential type',
+      options: credentialTypeOptions(),
+    }),
+  ) as CredentialType;
+
+  const users = loadUsers();
+  let cred_user_id: string | null = null;
+  if (users.length) {
+    const userChoice = checkCancel(
+      await p.select({
+        message: 'Link to a user?',
+        options: [
+          { value: '__none__', label: chalk.dim('— No User —') },
+          ...users.map((u) => ({ value: u.id, label: u.name })),
+        ],
+      }),
+    ) as string;
+    cred_user_id = userChoice === '__none__' ? null : userChoice;
+  }
+
+  const publicKey = readPublicKey();
+  const id = newId();
+  const createdAt = new Date().toISOString();
+
+  if (type === 'ssh_key') {
+    const source = checkCancel(
+      await p.text({
+        message: 'Name / label (source)',
+        placeholder: 'e.g. server-prod',
+      }),
+    );
+    const description = checkCancel(
+      await p.text({ message: 'Description (optional)', defaultValue: '' }),
+    );
+    const privateKeyPath = checkCancel(
+      await p.text({
+        message: 'Private key file path',
+        placeholder: '~/.ssh/id_rsa',
+        validate(v) {
+          if (!v) return 'Required';
+          if (!existsSync(resolvePath(v))) return 'File not found';
+        },
+      }),
+    );
+    const publicKeyPath = checkCancel(
+      await p.text({
+        message: 'Public key file path',
+        placeholder: '~/.ssh/id_rsa.pub',
+        validate(v) {
+          if (!v) return 'Required';
+          if (!existsSync(resolvePath(v))) return 'File not found';
+        },
+      }),
+    );
+
+    const privateKeyContent = readFileSync(resolvePath(privateKeyPath), 'utf8');
+    const publicKeyContent = readFileSync(resolvePath(publicKeyPath), 'utf8');
+
+    const entry: SshKeyEntry = {
+      id,
+      type,
+      source,
+      description: description || '',
+      createdAt,
+      cred_user_id,
+      encrypted_private_key: encryptData(publicKey, privateKeyContent),
+      public_key: publicKeyContent,
+    };
+
+    addEntry(entry);
+    p.log.success(
+      chalk.green(`✔ SSH Key '${chalk.bold(source)}' saved successfully.`),
+    );
+    return;
+  }
+
+  if (type === 'ssh_cred') {
+    const source = checkCancel(
+      await p.text({
+        message: 'Name / label (source)',
+        placeholder: 'e.g. server-prod',
+      }),
+    );
+    const host = checkCancel(
+      await p.text({ message: 'Host', placeholder: '192.168.1.1' }),
+    );
+    const portInput = checkCancel(
+      await p.text({
+        message: 'Port',
+        placeholder: '22',
+        initialValue: '22',
+        validate(v) {
+          if (v && Number.isNaN(Number(v))) return 'Port must be a number';
+        },
+      }),
+    );
+    const username = checkCancel(await p.text({ message: 'Username' }));
+    const password = await passwordOrGenerate();
+    const description = checkCancel(
+      await p.text({ message: 'Description (optional)', defaultValue: '' }),
+    );
+
+    const entry: SshCredEntry = {
+      id,
+      type,
+      source,
+      description: description || '',
+      createdAt,
+      cred_user_id,
+      host,
+      port: Number(portInput || '22'),
+      username,
+      encrypted_password: encryptData(publicKey, password),
+    };
+
+    addEntry(entry);
+    p.log.success(
+      chalk.green(
+        `✔ SSH Credential '${chalk.bold(source)}' saved successfully.`,
+      ),
+    );
+    return;
+  }
+
+  // github, gitlab, gmail, bank, website
+  const source = checkCancel(
+    await p.text({
+      message: 'Source / Name (e.g. github.com, bank name, website URL)',
+    }),
+  );
+  const username = checkCancel(
+    await p.text({ message: 'Username / Email / Account number' }),
+  );
+  const password = await passwordOrGenerate();
+  const description = checkCancel(
+    await p.text({ message: 'Description (optional)', defaultValue: '' }),
+  );
+
+  let extra: Record<string, string> | undefined;
+
+  if (type === 'bank') {
+    const accountNumber = checkCancel(
+      await p.text({ message: 'Account number (optional)', defaultValue: '' }),
+    );
+    if (accountNumber)
+      extra = { ...(extra || {}), account_number: accountNumber };
+  }
+
+  if (type === 'website') {
+    const url = checkCancel(
+      await p.text({ message: 'Website URL (optional)', defaultValue: '' }),
+    );
+    if (url) extra = { ...(extra || {}), url };
+  }
+
+  const entry: SimpleCredentialEntry = {
+    id,
+    type,
+    source,
+    description: description || '',
+    createdAt,
+    cred_user_id,
+    username,
+    encrypted_password: encryptData(publicKey, password),
+    extra,
+  };
+
+  addEntry(entry);
+  p.log.success(
+    chalk.green(`✔ Credential '${chalk.bold(source)}' saved successfully.`),
+  );
+}

package/src/command-pages/generatePassword.ts

@@ -0,0 +1,13 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { promptGeneratePassword } from '../generator';
+import { passwordBox } from '../ui';
+
+export async function generatePasswordFlow() {
+  const generated = await promptGeneratePassword();
+  if (!generated) {
+    p.log.warn(chalk.yellow('Generate password dibatalkan.'));
+    return;
+  }
+  console.log(passwordBox(generated));
+}

package/src/command-pages/listCredentials.ts

@@ -0,0 +1,21 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { entriesTable } from '../ui';
+import { pickFilteredEntries } from '../utils';
+
+export async function listCredentialsFlow() {
+  const { entries, users, total } = await pickFilteredEntries();
+
+  if (!total) {
+    p.log.warn(chalk.yellow('No credentials saved yet.'));
+    return;
+  }
+
+  if (!entries.length) {
+    p.log.warn(chalk.yellow('No credentials found for this user.'));
+    return;
+  }
+
+  console.log();
+  console.log(entriesTable(entries, users));
+}

package/src/command-pages/manageUsers.ts

@@ -0,0 +1,98 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadUsers, addUser, updateUser, deleteUser, newId } from '../store';
+import { printBanner, pressEnterHint } from '../ui';
+import { checkCancel } from '../utils';
+
+export async function manageUsersFlow() {
+  while (true) {
+    printBanner();
+    const users = loadUsers();
+
+    if (users.length) {
+      console.log();
+      const lines = users.map(
+        (u, i) =>
+          `  ${chalk.dim(`${i + 1}.`)} ${chalk.whiteBright(u.name)}  ${chalk.dim(u.id)}`,
+      );
+      console.log(chalk.bold.cyan('👤 Users:'));
+      console.log(lines.join('\n'));
+      console.log();
+    } else {
+      console.log(chalk.dim('\n  No users registered yet.\n'));
+    }
+
+    const action = checkCancel(
+      await p.select({
+        message: 'Manage Users',
+        options: [
+          { value: 'add', label: `${chalk.green('+')} Add User` },
+          { value: 'edit', label: `${chalk.yellow('✏️ ')} Edit User` },
+          { value: 'delete', label: `${chalk.red('🗑 ')} Delete User` },
+          { value: 'back', label: chalk.dim('← Back') },
+        ],
+      }),
+    );
+
+    if (action === 'back') return;
+
+    if (action === 'add') {
+      const name = checkCancel(
+        await p.text({ message: 'User name', placeholder: 'e.g. John Doe' }),
+      );
+      addUser({ id: newId(), name });
+      p.log.success(
+        chalk.green(`✔ User '${chalk.bold(name)}' added successfully.`),
+      );
+    } else if (action === 'edit') {
+      if (!users.length) {
+        p.log.warn(chalk.yellow('No users yet.'));
+      } else {
+        const selectedId = checkCancel(
+          await p.select({
+            message: 'Select user to edit',
+            options: users.map((u) => ({ value: u.id, label: u.name })),
+          }),
+        ) as string;
+        const user = users.find((u) => u.id === selectedId)!;
+        const name = checkCancel(
+          await p.text({ message: 'New name', initialValue: user.name }),
+        );
+        updateUser({ ...user, name });
+        p.log.success(
+          chalk.green(`✔ User '${chalk.bold(name)}' updated successfully.`),
+        );
+      }
+    } else if (action === 'delete') {
+      if (!users.length) {
+        p.log.warn(chalk.yellow('No users yet.'));
+      } else {
+        const selectedId = checkCancel(
+          await p.select({
+            message: 'Select user to delete',
+            options: users.map((u) => ({ value: u.id, label: u.name })),
+          }),
+        ) as string;
+        const user = users.find((u) => u.id === selectedId)!;
+        const confirmed = checkCancel(
+          await p.confirm({
+            message: `Delete user '${chalk.bold(user.name)}'? Linked credentials will not be deleted.`,
+            initialValue: false,
+          }),
+        );
+        if (confirmed) {
+          deleteUser(user.id);
+          p.log.success(
+            chalk.green(
+              `✔ User '${chalk.bold(user.name)}' deleted successfully.`,
+            ),
+          );
+        } else {
+          p.log.info(chalk.dim('Cancelled.'));
+        }
+      }
+    }
+
+    await p.text({ message: pressEnterHint(), defaultValue: '' });
+  }
+}