dong-pass 0.1.0__tar.gz

dong_pass-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dong-labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dong_pass-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: dong-pass
+Version: 0.1.0
+Summary: 密码咚 - 账号密码管理 CLI
+Author: gudong
+License-File: LICENSE
+Keywords: account,cli,password,security
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# 密码咚（dong-pass）
+
+账号密码管理 CLI - 帮你安全存储和管理账号密码
+
+## 安装
+
+```bash
+pipx install dong-pass
+```
+
+## 快速开始
+
+```bash
+# 初始化
+dong-pass init
+
+# 添加账号
+dong-pass add github --account gudongtongxue --password "Gudong123!@#" --category "个人"
+
+# 查询账号
+dong-pass get github
+
+# 列出所有
+dong-pass list
+
+# 搜索
+dong-pass search "github"
+```
+
+## 命令
+
+| 命令 | 说明 |
+|------|------|
+| `init` | 初始化数据库 |
+| `add` | 添加账号 |
+| `get` | 获取账号 |
+| `list` | 列出所有 |
+| `search` | 搜索 |
+| `update` | 更新账号 |
+| `delete` | 删除账号 |
+| `stats` | 统计信息 |
+| `export` | 导出为 JSON |
+| `import` | 从 JSON 导入 |
+| `set-master` | 设置主密码 |
+| `change-master` | 更改主密码 |
+| `remove-encrypt` | 移除加密 |
+
+## 加密存储
+
+```bash
+# 设置主密码（加密模式）
+dong-pass init --master-password "MySecretKey"
+
+# 添加时加密
+dong-pass add github --account gudong --password "123456" --encrypt
+
+# 查询时需要输入主密码
+dong-pass get github
+# 输入主密码: MySecretKey
+# 显示密码: 123456
+```
+
+## 数据库
+
+数据存储在 `~/.dong/accounts.db`
+
+## License
+
+MIT

dong_pass-0.1.0/README.md

@@ -0,0 +1,69 @@
+# 密码咚（dong-pass）
+
+账号密码管理 CLI - 帮你安全存储和管理账号密码
+
+## 安装
+
+```bash
+pipx install dong-pass
+```
+
+## 快速开始
+
+```bash
+# 初始化
+dong-pass init
+
+# 添加账号
+dong-pass add github --account gudongtongxue --password "Gudong123!@#" --category "个人"
+
+# 查询账号
+dong-pass get github
+
+# 列出所有
+dong-pass list
+
+# 搜索
+dong-pass search "github"
+```
+
+## 命令
+
+| 命令 | 说明 |
+|------|------|
+| `init` | 初始化数据库 |
+| `add` | 添加账号 |
+| `get` | 获取账号 |
+| `list` | 列出所有 |
+| `search` | 搜索 |
+| `update` | 更新账号 |
+| `delete` | 删除账号 |
+| `stats` | 统计信息 |
+| `export` | 导出为 JSON |
+| `import` | 从 JSON 导入 |
+| `set-master` | 设置主密码 |
+| `change-master` | 更改主密码 |
+| `remove-encrypt` | 移除加密 |
+
+## 加密存储
+
+```bash
+# 设置主密码（加密模式）
+dong-pass init --master-password "MySecretKey"
+
+# 添加时加密
+dong-pass add github --account gudong --password "123456" --encrypt
+
+# 查询时需要输入主密码
+dong-pass get github
+# 输入主密码: MySecretKey
+# 显示密码: 123456
+```
+
+## 数据库
+
+数据存储在 `~/.dong/accounts.db`
+
+## License
+
+MIT

dong_pass-0.1.0/agent/TOOLS.md

@@ -0,0 +1,120 @@
+# TOOLS.md - 工具箱
+
+我的核心工具是 `dong-pass` CLI。
+
+## 安装
+
+```bash
+pipx install dong-pass
+```
+
+## 命令列表
+
+### 初始化
+
+```bash
+dong-pass init
+dong-pass init --master-password "MySecretKey"  # 加密模式
+```
+
+### 添加账号
+
+```bash
+# 添加 GitHub 账号
+dong-pass add github --account gudongtongxue --password "Gudong123!@#" --category "个人"
+
+# 添加阿里云账号（加密）
+dong-pass add aliyun --account gudong@aliyun.com --password "Aliyun456$" --category "工作" --encrypt
+
+# 添加微博账号（带备注）
+dong-pass add weibo --account gudongtongxue --password "Weibo789#" --nickname "工作微博" --category "社交"
+```
+
+### 查询账号
+
+```bash
+dong-pass get github
+
+# 输出：
+# 网站：github.com
+# 账号：gudongtongxue
+# 密码：Gudong123!@#
+# 分类：个人
+```
+
+### 列出所有
+
+```bash
+# 列出所有
+dong-pass list
+
+# 列出工作类
+dong-pass list --category 工作
+```
+
+### 搜索
+
+```bash
+# 搜索包含 "aliyun" 的账号
+dong-pass search aliyun
+
+# 搜索所有个人类账号
+dong-pass search --category 个人
+```
+
+### 更新账号
+
+```bash
+# 更新密码
+dong-pass update github --password "NewPassword123!"
+
+# 更新分类
+dong-pass update weibo --category "个人"
+```
+
+### 删除账号
+
+```bash
+# 删除账号（需要确认）
+dong-pass delete github
+
+# 强制删除（不确认）
+dong-pass delete github --force
+```
+
+### 统计信息
+
+```bash
+dong-pass stats
+```
+
+### 导出/导入
+
+```bash
+# 导出为 JSON
+dong-pass export --output accounts.json
+
+# 从 JSON 导入
+dong-pass import --input accounts.json
+```
+
+### 加密管理
+
+```bash
+# 设置主密码（首次设置）
+dong-pass set-master
+
+# 更改主密码
+dong-pass change-master
+
+# 移除加密（明文化）
+dong-pass remove-encrypt
+```
+
+## 数据库
+
+数据存储在 `~/.dong/accounts.db`
+
+---
+
+*🔒 安全存储，随时访问*

dong_pass-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dong-pass"
+version = "0.1.0"
+description = "密码咚 - 账号密码管理 CLI"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{name = "gudong"}]
+keywords = ["cli", "password", "account", "security"]
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.0.0",
+    "cryptography>=41.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.scripts]
+dong-pass = "pass.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pass"]

dong_pass-0.1.0/src/pass/__init__.py

@@ -0,0 +1,3 @@
+"""密码咚 - 账号密码管理 CLI"""
+
+__version__ = "0.1.0"

dong_pass-0.1.0/src/pass/cli.py

@@ -0,0 +1,61 @@
+"""密码咚 CLI 主入口"""
+
+import typer
+from rich.console import Console
+from dong import json_output
+from . import __version__
+
+console = Console()
+
+app = typer.Typer(
+    name="dong-pass",
+    help="密码咚 - 账号密码管理 CLI",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+# 导入命令
+from .commands import (
+    init,
+    add,
+    get,
+    ls,
+    search,
+    update,
+    delete,
+    stats,
+    export,
+    import_cmd,
+    set_master,
+    change_master,
+    remove_encrypt,
+)
+
+# 注册命令
+app.command()(init.init)
+app.command()(add.add)
+app.command()(get.get)
+app.command(name="list")(ls.list_accounts)
+app.command()(search.search)
+app.command()(update.update)
+app.command()(delete.delete)
+app.command()(stats.stats)
+app.command()(export.export)
+app.command()(import_cmd.import_cmd)
+app.command()(set_master.set_master)
+app.command()(change_master.change_master)
+app.command()(remove_encrypt.remove_encrypt)
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", "-v", help="显示版本"),
+):
+    """密码咚 - 账号密码管理 CLI"""
+    if version:
+        console.print(f"dong-pass {__version__}")
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

dong_pass-0.1.0/src/pass/commands/__init__.py

@@ -0,0 +1,19 @@
+"""命令模块"""
+
+from . import init, add, get, ls, search, update, delete, stats, export, import_cmd, set_master, change_master, remove_encrypt
+
+__all__ = [
+    "init",
+    "add",
+    "get",
+    "ls",
+    "search",
+    "update",
+    "delete",
+    "stats",
+    "export",
+    "import_cmd",
+    "set_master",
+    "change_master",
+    "remove_encrypt",
+]

dong_pass-0.1.0/src/pass/commands/add.py

@@ -0,0 +1,58 @@
+"""add 命令"""
+
+import typer
+from ..db import PassDatabase, get_cursor
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def add(
+    site: str = typer.Argument(..., help="网站名称"),
+    account: str = typer.Option(..., "--account", "-a", help="账号"),
+    password: str = typer.Option(..., "--password", "-p", help="密码"),
+    nickname: str = typer.Option(None, "--nickname", help="昵称"),
+    category: str = typer.Option(None, "--category", "-c", help="分类（工作/个人/金融/社交）"),
+    note: str = typer.Option(None, "--note", help="备注"),
+    encrypt: bool = typer.Option(False, "--encrypt", help="加密存储"),
+):
+    """添加账号密码"""
+    from ..db import is_initialized
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    # 判断是否需要主密码
+    need_master = encrypt
+    master_password = None
+    if need_master:
+        master_password = typer.prompt("输入主密码以加密", password=True)
+        if not master_password:
+            raise DongError("NO_MASTER_PASSWORD", "加密存储需要主密码")
+
+    # 加密密码
+    db = PassDatabase(master_password)
+    if encrypt:
+        encrypted_pwd = db.encrypt(password)
+    else:
+        encrypted_pwd = password
+
+    with get_cursor(master_password) as cur:
+        try:
+            cur.execute("""
+                INSERT INTO accounts (site, account, password, nickname, category, note, encrypted)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (site.lower(), account, encrypted_pwd, nickname, category, note, encrypt))
+        except sqlite3.IntegrityError:
+            raise DongError("DUPLICATE_SITE", f"网站 '{site}' 已存在，请使用 update 命令更新")
+
+    console.print(f"[green]✅ 已添加账号：{site}[/green]")
+
+    return {
+        "site": site.lower(),
+        "account": account,
+        "encrypted": encrypt,
+        "nickname": nickname,
+        "category": category,
+    }

dong_pass-0.1.0/src/pass/commands/change_master.py

@@ -0,0 +1,56 @@
+"""change_master 命令"""
+
+import typer
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def change_master():
+    """更改主密码"""
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    # 检查是否已加密
+    with get_cursor() as cur:
+        cur.execute("SELECT encrypted FROM accounts LIMIT 1")
+        row = cur.fetchone()
+
+    if not row or not row["encrypted"]:
+        raise DongError("NOT_ENCRYPTED", "数据库不是加密模式")
+
+    # 输入旧主密码
+    old_password = typer.prompt("输入当前主密码", password=True)
+
+    if not old_password:
+        raise DongError("INVALID_PASSWORD", "主密码不能为空")
+
+    # 输入新主密码
+    new_password = typer.prompt("输入新主密码", password=True, confirmation_prompt=True)
+
+    if not new_password:
+        raise DongError("INVALID_PASSWORD", "新主密码不能为空")
+
+    # 获取数据库
+    db = PassDatabase(old_password)
+
+    # 重新加密所有密码
+    with get_cursor(old_password) as cur:
+        cur.execute("SELECT id, account, password FROM accounts")
+        rows = cur.fetchall()
+
+        for row in rows:
+            account_id = row["id"]
+            encrypted_pwd = row["password"]
+            # 重新加密
+            new_encrypted_pwd = db.encrypt(encrypted_pwd)
+            cur.execute(
+                "UPDATE accounts SET password = ? WHERE id = ?",
+                (new_encrypted_pwd, account_id)
+            )
+
+    console.print("[green]✅ 主密码已更改[/green]")
+
+    return {"message": "主密码更改成功"}

dong_pass-0.1.0/src/pass/commands/delete.py

@@ -0,0 +1,39 @@
+"""delete 命令"""
+
+import typer
+from ..db import get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def delete(
+    site: str = typer.Option(..., help="网站名称"),
+    force: bool = typer.Option(False, "--force", "-f", help="强制删除，不确认"),
+):
+    """删除账号"""
+    from ..db import PassDatabase, get_db_path
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    with get_cursor() as cur:
+        cur.execute("SELECT site FROM accounts WHERE site = ?", (site.lower(),))
+        row = cur.fetchone()
+
+        if not row:
+            raise DongError("NOT_FOUND", f"未找到网站：{site}")
+
+        site_name = row["site"]
+
+    if not force:
+        if not typer.confirm(f"确定要删除网站 '{site_name}' 吗？"):
+            return {"cancelled": True}
+
+    with get_cursor() as cur:
+        cur.execute("DELETE FROM accounts WHERE site = ?", (site.lower(),))
+
+    console.print(f"[green]✅ 已删除账号：{site_name}[/green]")
+
+    return {"site": site_name, "deleted": True}

dong_pass-0.1.0/src/pass/commands/export.py

@@ -0,0 +1,51 @@
+"""export 命令"""
+
+import typer
+import json
+from rich.console import Console
+from ..db import get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def export(
+    output: str = typer.Option(None, "--output", "-o", help="输出文件路径"),
+):
+    """导出账号到 JSON"""
+    from ..db import get_db_path
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    db_path = get_db_path()
+    if not db_path.exists():
+        raise DongError("NOT_INITIALIZED", "数据库不存在，请运行 dong-pass init")
+
+    with get_cursor() as cur:
+        cur.execute("SELECT * FROM accounts")
+        rows = cur.fetchall()
+
+    if not rows:
+        console.print("暂无账号记录")
+        return {"message": "无数据导出", "accounts": []}
+
+    # 转换为字典
+    accounts = []
+    for row in rows:
+        account = dict(row)
+        # 不导出密码（除非用户有特殊需求）
+        # password_encrypted = account["password"]
+        accounts.append(account)
+
+    data = {"accounts": accounts, "exported_at": "2026-03-19"}
+
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        console.print(f"[green]✅ 已导出到：{output}[/green]")
+    else:
+        console.print(json.dumps(data, ensure_ascii=False, indent=2))
+
+    return {"message": "导出成功", "count": len(accounts)}

dong_pass-0.1.0/src/pass/commands/get.py

@@ -0,0 +1,83 @@
+"""get 命令"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from datetime import datetime
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def get(
+    site: str = typer.Argument(..., help="网站名称"),
+):
+    """获取账号密码"""
+    from ..db import get_db_path
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    db_path = get_db_path()
+    if not db_path.exists():
+        raise DongError("NOT_INITIALIZED", "数据库不存在，请运行 dong-pass init")
+
+    # 判断是否加密
+    db = PassDatabase()
+    with get_cursor() as cur:
+        cur.execute("SELECT * FROM accounts WHERE site = ?", (site.lower(),))
+        row = cur.fetchone()
+
+    if not row:
+        raise DongError("NOT_FOUND", f"未找到网站：{site}")
+
+    site_name = row["site"]
+    account = row["account"]
+    password_encrypted = row["password"]
+    nickname = row["nickname"] or "-"
+    category = row["category"] or "-"
+    encrypted = row["encrypted"]
+    last_used_at = row["last_used_at"]
+    created_at = row["created_at"]
+
+    # 解密密码
+    if encrypted:
+        master_password = typer.prompt(f"请输入主密码以解密 {site_name} 的密码", password=True)
+        db = PassDatabase(master_password)
+        password = db.decrypt(password_encrypted)
+    else:
+        password = password_encrypted
+
+    # 更新最后使用时间
+    with get_cursor() as cur:
+        cur.execute("UPDATE accounts SET last_used_at = CURRENT_TIMESTAMP WHERE site = ?", (site.lower(),))
+
+    # 渲染输出
+    table = Table(title=f"账号信息：{site_name}")
+    table.add_column("项目", style="cyan")
+    table.add_column("内容", style="green")
+
+    table.add_row("网站", site_name)
+    table.add_row("账号", account)
+    table.add_row("密码", password)
+    if nickname != "-":
+        table.add_row("昵称", nickname)
+    if category != "-":
+        table.add_row("分类", category)
+    if last_used_at:
+        table.add_row("最后使用", last_used_at)
+    table.add_row("创建时间", created_at)
+
+    console.print(table)
+
+    return {
+        "site": site_name,
+        "account": account,
+        "password": password,
+        "encrypted": encrypted,
+        "nickname": nickname,
+        "category": category,
+        "last_used_at": last_used_at,
+    }

dong_pass-0.1.0/src/pass/commands/import_cmd.py

@@ -0,0 +1,59 @@
+"""import 命令"""
+
+import typer
+import json
+from ..db import get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def import_cmd(
+    input: str = typer.Option(..., "--input", "-i", help="输入文件路径"),
+):
+    """从 JSON 导入账号"""
+    from ..db import is_initialized
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    try:
+        with open(input, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        raise DongError("FILE_NOT_FOUND", f"文件不存在：{input}")
+    except json.JSONDecodeError as e:
+        raise DongError("INVALID_JSON", f"JSON 格式错误：{e}")
+
+    accounts = data.get("accounts", [])
+    if not accounts:
+        return {"message": "文件中没有账号数据", "imported": 0}
+
+    with get_cursor() as cur:
+        imported = 0
+        for account in accounts:
+            site = account.get("site")
+            account_field = account.get("account")
+            password_field = account.get("password")
+            nickname = account.get("nickname")
+            category = account.get("category")
+            note = account.get("note")
+            encrypted = account.get("encrypted", False)
+
+            if not site or not account_field:
+                continue
+
+            try:
+                cur.execute("""
+                    INSERT INTO accounts (site, account, password, nickname, category, note, encrypted)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                """, (site.lower(), account_field, password_field, nickname, category, note, encrypted))
+                imported += 1
+            except sqlite3.IntegrityError:
+                # 跳过已存在的网站
+                pass
+
+    console.print(f"[green]✅ 已导入 {imported} 个账号[/green]")
+
+    return {"message": "导入成功", "imported": imported}

dong_pass-0.1.0/src/pass/commands/init.py

@@ -0,0 +1,35 @@
+"""init 命令"""
+
+import typer
+from rich.console import Console
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def init(
+    master_password: str = typer.Option(None, "--master-password", help="主密码（用于加密）"),
+):
+    """初始化数据库"""
+    from ..db import PassDatabase, init_database, is_initialized
+
+    if is_initialized():
+        console.print("[yellow]数据库已初始化[/yellow]")
+        return {"message": "数据库已初始化"}
+
+    # 设置主密码
+    password = master_password
+    if not password:
+        password = typer.prompt("设置主密码（用于加密，留空则明文存储）", password=True)
+
+    # 初始化数据库
+    init_database()
+
+    if password:
+        console.print("[green]✅ 数据库初始化成功（加密模式）[/green]")
+        console.print("[yellow]⚠️ 请妥善保管主密码！忘记后密码将无法恢复。[/yellow]")
+    else:
+        console.print("[green]✅ 数据库初始化成功（明文模式）[/green]")
+
+    return {"message": "数据库初始化成功", "encrypted": bool(password)}

dong_pass-0.1.0/src/pass/commands/ls.py

@@ -0,0 +1,86 @@
+"""ls 命令"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def list_accounts(
+    category: str = typer.Option(None, "--category", "-c", help="按分类筛选"),
+    limit: int = typer.Option(50, "--limit", "-l", help="限制数量"),
+):
+    """列出所有账号"""
+    from ..db import get_db_path
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    db_path = get_db_path()
+    if not db_path.exists():
+        raise DongError("NOT_INITIALIZED", "数据库不存在，请运行 dong-pass init")
+
+    with get_cursor() as cur:
+        if category:
+            cur.execute("""
+                SELECT * FROM accounts WHERE category = ?
+                ORDER BY last_used_at DESC
+                LIMIT ?
+            """, (category, limit))
+        else:
+            cur.execute("""
+                SELECT * FROM accounts
+                ORDER BY last_used_at DESC
+                LIMIT ?
+            """, (limit,))
+
+        rows = cur.fetchall()
+
+    if not rows:
+        console.print("暂无账号记录")
+        return {"items": [], "total": 0}
+
+    # 渲染表格
+    table = Table(title=f"账号列表 {f'（分类：{category}）' if category else ''}")
+    table.add_column("ID", justify="right", style="cyan")
+    table.add_column("网站", style="green")
+    table.add_column("账号", style="yellow")
+    table.add_column("昵称", style="blue")
+    table.add_column("分类", style="magenta")
+    table.add_column("最后使用")
+
+    items = []
+    for row in rows:
+        expire_id, site, account, password, nickname, category, note, encrypted, created_at, updated_at, last_used_at = row
+
+        nickname_str = nickname or "-"
+        category_str = category or "-"
+        last_used_str = last_used_at[:10] if last_used_at else "-"
+
+        status = "🔒" if encrypted else "🔓"
+
+        table.add_row(
+            str(expire_id),
+            site,
+            account,
+            nickname_str,
+            category_str,
+            last_used_str,
+        )
+
+        items.append({
+            "id": expire_id,
+            "site": site,
+            "account": account,
+            "nickname": nickname,
+            "category": category,
+            "encrypted": encrypted,
+        })
+
+    console.print(table)
+
+    return {"items": items, "total": len(items)}

dong_pass-0.1.0/src/pass/commands/remove_encrypt.py

@@ -0,0 +1,58 @@
+"""remove_encrypt 命令"""
+
+import typer
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def remove_encrypt():
+    """移除加密（明文化）"""
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    # 检查是否已加密
+    with get_cursor() as cur:
+        cur.execute("SELECT encrypted FROM accounts LIMIT 1")
+        row = cur.fetchone()
+
+    if not row or not row["encrypted"]:
+        raise DongError("NOT_ENCRYPTED", "数据库不是加密模式")
+
+    # 输入主密码
+    master_password = typer.prompt("输入主密码以验证", password=True)
+
+    if not master_password:
+        raise DongError("INVALID_PASSWORD", "主密码不能为空")
+
+    # 验证密码
+    db = PassDatabase(master_password)
+    try:
+        # 测试解密一个密码
+        with get_cursor(master_password) as cur:
+            cur.execute("SELECT password FROM accounts LIMIT 1")
+            row = cur.fetchone()
+            db.decrypt(row["password"])
+    except Exception:
+        raise DongError("INVALID_PASSWORD", "主密码错误")
+
+    # 明文化所有密码
+    with get_cursor(master_password) as cur:
+        cur.execute("SELECT id, password FROM accounts")
+        rows = cur.fetchall()
+
+        for row in rows:
+            account_id = row["id"]
+            encrypted_pwd = row["password"]
+            # 转换为明文
+            plain_pwd = db.decrypt(encrypted_pwd)
+            cur.execute(
+                "UPDATE accounts SET password = ?, encrypted = 0 WHERE id = ?",
+                (plain_pwd, account_id)
+            )
+
+    console.print("[green]✅ 加密已移除，所有密码已明文化[/green]")
+
+    return {"message": "加密已移除"}

dong_pass-0.1.0/src/pass/commands/search.py

@@ -0,0 +1,73 @@
+"""search 命令"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def search(
+    keyword: str = typer.Argument(..., help="搜索关键词"),
+    category: str = typer.Option(None, "--category", help="按分类筛选"),
+):
+    """搜索账号"""
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    search_pattern = f"%{keyword}%"
+    with get_cursor() as cur:
+        if category:
+            cur.execute("""
+                SELECT * FROM accounts WHERE site LIKE ? OR account LIKE ? OR nickname LIKE ? OR category = ?
+                ORDER BY last_used_at DESC
+            """, (search_pattern, search_pattern, search_pattern, category))
+        else:
+            cur.execute("""
+                SELECT * FROM accounts WHERE site LIKE ? OR account LIKE ? OR nickname LIKE ?
+                ORDER BY last_used_at DESC
+            """, (search_pattern, search_pattern, search_pattern))
+
+        rows = cur.fetchall()
+
+    if not rows:
+        console.print(f"[yellow]未找到包含 '{keyword}' 的账号[/yellow]")
+        return {"items": [], "total": 0}
+
+    # 渲染表格
+    table = Table(title=f"搜索结果：{keyword}")
+    table.add_column("ID", justify="right", style="cyan")
+    table.add_column("网站", style="green")
+    table.add_column("账号", style="yellow")
+    table.add_column("昵称", style="blue")
+    table.add_column("分类", style="magenta")
+
+    items = []
+    for row in rows:
+        expire_id, site, account, password, nickname, category, note, encrypted, created_at, updated_at, last_used_at = row
+
+        nickname_str = nickname or "-"
+        category_str = category or "-"
+
+        table.add_row(
+            str(expire_id),
+            site,
+            account,
+            nickname_str,
+            category_str,
+        )
+
+        items.append({
+            "id": expire_id,
+            "site": site,
+            "account": account,
+            "nickname": nickname,
+            "category": category,
+        })
+
+    console.print(table)
+
+    return {"items": items, "total": len(items)}

dong_pass-0.1.0/src/pass/commands/set_master.py

@@ -0,0 +1,33 @@
+"""set_master 命令"""
+
+import typer
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def set_master():
+    """设置主密码（首次设置）"""
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    # 检查是否已有主密码
+    with get_cursor() as cur:
+        cur.execute("SELECT encrypted FROM accounts LIMIT 1")
+        row = cur.fetchone()
+
+    if row and row["encrypted"]:
+        raise DongError("ALREADY_ENCRYPTED", "数据库已经是加密模式，请使用 change-master 命令")
+
+    # 设置新主密码
+    master_password = typer.prompt("设置主密码（用于加密），不能为空", password=True, confirmation_prompt=True)
+
+    if not master_password:
+        raise DongError("INVALID_PASSWORD", "主密码不能为空")
+
+    console.print("[green]✅ 主密码设置成功[/green]")
+    console.print("[yellow]⚠️ 请妥善保管主密码！忘记后密码将无法恢复。[/yellow]")
+
+    return {"message": "主密码设置成功", "encrypted": True}

dong_pass-0.1.0/src/pass/commands/stats.py

@@ -0,0 +1,62 @@
+"""stats 命令"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..db import PassDatabase, get_cursor, is_initialized
+from dong import json_output, DongError
+
+console = Console()
+
+
+@json_output
+def stats():
+    """统计信息"""
+    from ..db import get_db_path
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    db_path = get_db_path()
+    if not db_path.exists():
+        raise DongError("NOT_INITIALIZED", "数据库不存在，请运行 dong-pass init")
+
+    with get_cursor() as cur:
+        # 总数
+        cur.execute("SELECT COUNT(*) FROM accounts")
+        total = cur.fetchone()[0]
+
+        # 按分类统计
+        cur.execute("""
+            SELECT category, COUNT(*) as count
+            FROM accounts
+            GROUP BY category
+        """)
+        category_stats = cur.fetchall()
+
+    if total == 0:
+        console.print("暂无账号记录")
+        return {"total": 0, "categories": []}
+
+    # 渲染表格
+    table = Table(title="账号统计")
+    table.add_column("分类", style="blue")
+    table.add_column("数量", justify="right", style="cyan")
+    table.add_column("占比", justify="right", style="green")
+
+    categories = []
+    for row in category_stats:
+        category, count = row
+        category = category or "未分类"
+        percentage = (count / total * 100)
+        table.add_row(category, str(count), f"{percentage:.1f}%")
+        categories.append({
+            "category": category,
+            "count": count,
+            "percentage": percentage,
+        })
+
+    table.add_row("总计", str(total), "100%")
+    console.print(table)
+
+    return {"total": total, "categories": categories}

dong_pass-0.1.0/src/pass/commands/update.py

@@ -0,0 +1,80 @@
+"""update 命令"""
+
+import typer
+from ..db import PassDatabase, get_cursor
+from dong import json_output, DongError
+
+console = typer.Console()
+
+
+@json_output
+def update(
+    site: str = typer.Argument(..., help="网站名称"),
+    account: str = typer.Option(None, "--account", help="账号"),
+    password: str = typer.Option(None, "--password", help="密码"),
+    nickname: str = typer.Option(None, "--nickname", help="昵称"),
+    category: str = typer.Option(None, "--category", help="分类"),
+    note: str = typer.Option(None, "--note", help="备注"),
+):
+    """更新账号"""
+    from ..db import is_initialized, PassDatabase
+
+    if not is_initialized():
+        raise DongError("NOT_INITIALIZED", "请先运行 dong-pass init")
+
+    # 判断是否需要主密码（如果修改密码且原记录已加密）
+    with get_cursor() as cur:
+        cur.execute("SELECT encrypted FROM accounts WHERE site = ?", (site.lower(),))
+        row = cur.fetchone()
+
+    if not row:
+        raise DongError("NOT_FOUND", f"未找到网站：{site}")
+
+    encrypted = row["encrypted"]
+    master_password = None
+    if password and encrypted:
+        master_password = typer.prompt("输入主密码以解密密码", password=True)
+
+    # 构建更新语句
+    updates = []
+    params = []
+
+    if account:
+        updates.append("account = ?")
+        params.append(account)
+    if password:
+        db = PassDatabase(master_password)
+        if encrypted:
+            encrypted_pwd = db.encrypt(password)
+        else:
+            encrypted_pwd = password
+        updates.append("password = ?")
+        params.append(encrypted_pwd)
+    if nickname:
+        updates.append("nickname = ?")
+        params.append(nickname)
+    if category:
+        updates.append("category = ?")
+        params.append(category)
+    if note:
+        updates.append("note = ?")
+        params.append(note)
+
+    if not updates:
+        raise DongError("NO_UPDATES", "没有指定要更新的字段")
+
+    updates.append("updated_at = CURRENT_TIMESTAMP")
+    params.append(site.lower())
+
+    with get_cursor(master_password) as cur:
+        cur.execute(
+            f"UPDATE accounts SET {', '.join(updates)} WHERE site = ?",
+            params
+        )
+
+        if cur.rowcount == 0:
+            raise DongError("NOT_FOUND", f"未找到网站：{site}")
+
+    console.print(f"[green]✅ 已更新账号：{site}[/green]")
+
+    return {"site": site.lower(), "updated": True}

dong_pass-0.1.0/src/pass/db/connection.py

@@ -0,0 +1,82 @@
+"""数据库连接管理"""
+
+import sqlite3
+from pathlib import Path
+from typing import Iterator
+from contextlib import contextmanager
+from cryptography.fernet import Fernet
+import getpass
+
+
+class PassDatabase:
+    """密码咚数据库类"""
+
+    def __init__(self, master_password: str = None):
+        self.db_path = self.get_db_path()
+        self.master_password = master_password
+        self.cipher = None
+        if master_password:
+            self.cipher = self._get_cipher(master_password)
+
+    @classmethod
+    def get_db_path(cls) -> Path:
+        """获取数据库路径"""
+        db_path = Path.home() / ".dong" / "accounts.db"
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        return db_path
+
+    def _get_cipher(self, password: str) -> Fernet:
+        """获取加密器"""
+        # 从密码生成密钥
+        key = Fernet.generate_key()
+        # 使用密码作为种子（实际应用中应该更安全的方式）
+        import hashlib
+        salt = b'dong-pass-salt-2026'
+        kdf_key = hashlib.pbkdf2_hmac(
+            'sha256',
+            password.encode(),
+            salt,
+            100000
+        )
+        # 转换为 Fernet key 格式
+        fernet_key = Fernet.generate_key(kdf_key)
+        return Fernet(fernet_key)
+
+    def encrypt(self, text: str) -> str:
+        """加密文本"""
+        if not self.cipher:
+            return text
+        return self.cipher.encrypt(text.encode()).decode()
+
+    def decrypt(self, encrypted: str) -> str:
+        """解密文本"""
+        if not self.cipher:
+            return encrypted
+        return self.cipher.decrypt(encrypted.encode()).decode()
+
+
+@contextmanager
+def get_cursor(master_password: str = None) -> Iterator[sqlite3.Cursor]:
+    """获取数据库游标"""
+    db = PassDatabase(master_password)
+    conn = sqlite3.connect(str(db.db_path))
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    try:
+        yield cursor
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+def get_db_path() -> Path:
+    """获取数据库路径"""
+    return PassDatabase.get_db_path()
+
+
+def close_connection():
+    """关闭数据库连接"""
+    pass

dong_pass-0.1.0/src/pass/db/schema.py

@@ -0,0 +1,60 @@
+"""数据库 Schema 管理"""
+
+from .connection import PassDatabase
+from datetime import datetime
+
+
+class PassSchemaManager:
+    """密码咚 Schema 管理器"""
+
+    def init_schema(self) -> None:
+        with PassDatabase.get_cursor() as cur:
+            self._create_accounts_table()
+            self._create_indexes()
+
+    def _create_accounts_table(self) -> None:
+        with PassDatabase.get_cursor() as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS accounts (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    site TEXT NOT NULL UNIQUE,
+                    account TEXT NOT NULL,
+                    password TEXT NOT NULL,
+                    nickname TEXT,
+                    category TEXT,
+                    note TEXT,
+                    encrypted BOOLEAN DEFAULT 0,
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    last_used_at TEXT
+                )
+            """)
+
+    def _create_indexes(self) -> None:
+        with PassDatabase.get_cursor() as cur:
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_accounts_category ON accounts(category)")
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_accounts_last_used ON accounts(last_used_at)")
+
+
+def init_database() -> dict:
+    """初始化数据库"""
+    manager = PassSchemaManager()
+    manager.init_schema()
+    return {"message": "数据库初始化成功"}
+
+
+def is_initialized() -> bool:
+    """检查数据库是否已初始化"""
+    db_path = PassDatabase.get_db_path()
+    if not db_path.exists():
+        return False
+
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cur = conn.cursor()
+        cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='accounts'")
+        result = cur.fetchone() is not None
+        conn.close()
+        return result
+    except Exception:
+        return False