kiwoom-cli 2.1.1__tar.gz → 2.2.1__tar.gz

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwoom-cli
-Version: 2.1.1
+Version: 2.2.1
 Summary: User-friendly CLI for the Kiwoom Securities REST API (키움증권)
 License: LicenseRef-kiwoom-cli-Source-Available-1.0
 Project-URL: Homepage, https://github.com/gejyn14/kiwoom-cli
@@ -84,6 +84,7 @@ $ kiwoom -f json account balance | jq       # AI 에이전트·스크립트 친
 
 ```bash
 # 1. 초기 설정 (appkey, secretkey → OS 키체인)
+#    토큰 저장 방식도 여기서 선택: keychain (기본) 또는 env (KIWOOM_TOKEN 직접 관리)
 kiwoom config setup
 
 # 2. 토큰 발급
@@ -108,14 +109,25 @@ kiwoom config show          # 현재 설정 확인
 
 ### 환경변수 설정
 
-도메인과 계좌번호는 환경변수로도 설정 가능합니다.
+도메인, 계좌번호, 프로필, 토큰은 환경변수로도 설정 가능합니다.
 
 ```bash
 export KIWOOM_DOMAIN="prod"       # prod 또는 mock
 export KIWOOM_ACCOUNT="1234567"   # 선택
+export KIWOOM_PROFILE="isa"       # 선택
+export KIWOOM_TOKEN="..."         # 선택: 키체인 대신 사용할 접근토큰 (샌드박스/CI용)
 ```
 
-appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요.
+appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요. `KIWOOM_TOKEN`은 만료·폐기 가능한 접근토큰만 담는 통로로, 키체인에 접근할 수 없는 환경(샌드박스, CI, AI 에이전트)에서 사용합니다 — 설정 시 키체인 토큰보다 우선합니다.
+
+### 토큰 저장 방식 (keychain vs env)
+
+`config setup`에서 토큰 저장 방식을 선택합니다.
+
+- **keychain** (기본): `auth login`이 토큰을 OS 키체인에 저장합니다. 본인 터미널에서 쓰는 일반적인 방식.
+- **env**: 토큰을 키체인에 저장하지 않습니다. `auth login`이 토큰과 `export KIWOOM_TOKEN=...` 명령을 출력하면 셸에서 실행하세요. 키체인 접근이 불가능한 환경(샌드박스, CI, 컨테이너)이 주 작업 환경일 때 적합합니다.
+
+이후 전환은 `kiwoom config set token_storage keychain|env`.
 
 ### 멀티 프로필
 
@@ -160,6 +172,26 @@ kiwoom order buy 005930 10 --type market --confirm
 - 페이지네이션(연속조회)은 자동 처리 — 에이전트가 커서를 관리할 필요가 없습니다.
 - 자세한 패턴은 [Wiki: AI 에이전트 가이드](https://github.com/gejyn14/kiwoom-cli/wiki/AI-Agents) 참고.
 
+### 샌드박스 환경 (키체인 접근 불가)
+
+샌드박스 셸, CI, 컨테이너에서는 OS 키체인을 읽을 수 없습니다. 이때는 본인 터미널에서 토큰을 발급받아 `KIWOOM_TOKEN`으로 전달하세요 — appkey/secretkey는 키체인 밖으로 나가지 않고, 토큰은 만료·폐기 가능합니다.
+
+```bash
+# 본인 터미널에서 (하루 1회 정도) — env 모드라면 login이 export 명령을 그대로 출력
+kiwoom config set token_storage env
+kiwoom auth login
+export KIWOOM_TOKEN='...'   # login 출력의 export 라인을 복사해 실행
+
+# 이 셸에서 에이전트를 실행하면 환경변수가 상속되어 모든 명령이 동작
+kiwoom auth status   # 토큰 있음 (환경변수 KIWOOM_TOKEN)
+```
+
+keychain 모드를 유지하면서 일회성으로 꺼내 쓰려면:
+
+```bash
+export KIWOOM_TOKEN=$(security find-generic-password -s kiwoom-cli -a "default:token" -w)  # macOS
+```
+
 ## 명령어 구조
 
 ```
@@ -513,11 +545,11 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 모든 인증정보(appkey, secretkey, 토큰)는 **OS 키체인**(macOS Keychain / Windows Credential Manager / Linux Secret Service)에 저장됩니다. 파일로 존재하지 않으며, 키체인이 디스크 저장 시 암호화를 담당합니다. `gh`, `aws`, `docker` CLI와 동일한 모델입니다.
 
-| 항목               | 저장 방식          | 프롬프트 |
-| ------------------ | ------------------ | :------: |
-| appkey / secretkey | OS 키체인          |    X     |
-| 토큰               | OS 키체인          |    X     |
-| config.toml        | 도메인, 계좌번호만 |    X     |
+| 항목               | 저장 방식                                  | 프롬프트 |
+| ------------------ | ------------------------------------------ | :------: |
+| appkey / secretkey | OS 키체인                                  |    X     |
+| 토큰               | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (선택) |    X     |
+| config.toml        | 도메인, 계좌번호, 토큰 저장 방식만         |    X     |
 
 - 모든 명령어는 비밀번호/생체인증 프롬프트 없이 동작 (AI 에이전트·자동화 친화적)
 - 앱 자체 암호화 계층은 의도적으로 두지 않음 — 추가 계층은 명령마다 잠금 해제 프롬프트를 요구하게 되어 CLI 사용성을 해침
@@ -530,9 +562,9 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 | 항목             | 값                                       |
 | ---------------- | ---------------------------------------- |
-| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌만) |
+| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌, 토큰 저장 방식만) |
 | appkey/secretkey | OS 키체인                                |
-| 토큰             | OS 키체인                                |
+| 토큰             | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (setup에서 선택) |
 | 캐시 디렉터리    | `~/.kiwoom/cache/`                       |
 | 운영 도메인      | `https://api.kiwoom.com`                 |
 | 모의투자 도메인  | `https://mockapi.kiwoom.com`             |

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/README.md

@@ -47,6 +47,7 @@ $ kiwoom -f json account balance | jq       # AI 에이전트·스크립트 친
 
 ```bash
 # 1. 초기 설정 (appkey, secretkey → OS 키체인)
+#    토큰 저장 방식도 여기서 선택: keychain (기본) 또는 env (KIWOOM_TOKEN 직접 관리)
 kiwoom config setup
 
 # 2. 토큰 발급
@@ -71,14 +72,25 @@ kiwoom config show          # 현재 설정 확인
 
 ### 환경변수 설정
 
-도메인과 계좌번호는 환경변수로도 설정 가능합니다.
+도메인, 계좌번호, 프로필, 토큰은 환경변수로도 설정 가능합니다.
 
 ```bash
 export KIWOOM_DOMAIN="prod"       # prod 또는 mock
 export KIWOOM_ACCOUNT="1234567"   # 선택
+export KIWOOM_PROFILE="isa"       # 선택
+export KIWOOM_TOKEN="..."         # 선택: 키체인 대신 사용할 접근토큰 (샌드박스/CI용)
 ```
 
-appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요.
+appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요. `KIWOOM_TOKEN`은 만료·폐기 가능한 접근토큰만 담는 통로로, 키체인에 접근할 수 없는 환경(샌드박스, CI, AI 에이전트)에서 사용합니다 — 설정 시 키체인 토큰보다 우선합니다.
+
+### 토큰 저장 방식 (keychain vs env)
+
+`config setup`에서 토큰 저장 방식을 선택합니다.
+
+- **keychain** (기본): `auth login`이 토큰을 OS 키체인에 저장합니다. 본인 터미널에서 쓰는 일반적인 방식.
+- **env**: 토큰을 키체인에 저장하지 않습니다. `auth login`이 토큰과 `export KIWOOM_TOKEN=...` 명령을 출력하면 셸에서 실행하세요. 키체인 접근이 불가능한 환경(샌드박스, CI, 컨테이너)이 주 작업 환경일 때 적합합니다.
+
+이후 전환은 `kiwoom config set token_storage keychain|env`.
 
 ### 멀티 프로필
 
@@ -123,6 +135,26 @@ kiwoom order buy 005930 10 --type market --confirm
 - 페이지네이션(연속조회)은 자동 처리 — 에이전트가 커서를 관리할 필요가 없습니다.
 - 자세한 패턴은 [Wiki: AI 에이전트 가이드](https://github.com/gejyn14/kiwoom-cli/wiki/AI-Agents) 참고.
 
+### 샌드박스 환경 (키체인 접근 불가)
+
+샌드박스 셸, CI, 컨테이너에서는 OS 키체인을 읽을 수 없습니다. 이때는 본인 터미널에서 토큰을 발급받아 `KIWOOM_TOKEN`으로 전달하세요 — appkey/secretkey는 키체인 밖으로 나가지 않고, 토큰은 만료·폐기 가능합니다.
+
+```bash
+# 본인 터미널에서 (하루 1회 정도) — env 모드라면 login이 export 명령을 그대로 출력
+kiwoom config set token_storage env
+kiwoom auth login
+export KIWOOM_TOKEN='...'   # login 출력의 export 라인을 복사해 실행
+
+# 이 셸에서 에이전트를 실행하면 환경변수가 상속되어 모든 명령이 동작
+kiwoom auth status   # 토큰 있음 (환경변수 KIWOOM_TOKEN)
+```
+
+keychain 모드를 유지하면서 일회성으로 꺼내 쓰려면:
+
+```bash
+export KIWOOM_TOKEN=$(security find-generic-password -s kiwoom-cli -a "default:token" -w)  # macOS
+```
+
 ## 명령어 구조
 
 ```
@@ -476,11 +508,11 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 모든 인증정보(appkey, secretkey, 토큰)는 **OS 키체인**(macOS Keychain / Windows Credential Manager / Linux Secret Service)에 저장됩니다. 파일로 존재하지 않으며, 키체인이 디스크 저장 시 암호화를 담당합니다. `gh`, `aws`, `docker` CLI와 동일한 모델입니다.
 
-| 항목               | 저장 방식          | 프롬프트 |
-| ------------------ | ------------------ | :------: |
-| appkey / secretkey | OS 키체인          |    X     |
-| 토큰               | OS 키체인          |    X     |
-| config.toml        | 도메인, 계좌번호만 |    X     |
+| 항목               | 저장 방식                                  | 프롬프트 |
+| ------------------ | ------------------------------------------ | :------: |
+| appkey / secretkey | OS 키체인                                  |    X     |
+| 토큰               | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (선택) |    X     |
+| config.toml        | 도메인, 계좌번호, 토큰 저장 방식만         |    X     |
 
 - 모든 명령어는 비밀번호/생체인증 프롬프트 없이 동작 (AI 에이전트·자동화 친화적)
 - 앱 자체 암호화 계층은 의도적으로 두지 않음 — 추가 계층은 명령마다 잠금 해제 프롬프트를 요구하게 되어 CLI 사용성을 해침
@@ -493,9 +525,9 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 | 항목             | 값                                       |
 | ---------------- | ---------------------------------------- |
-| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌만) |
+| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌, 토큰 저장 방식만) |
 | appkey/secretkey | OS 키체인                                |
-| 토큰             | OS 키체인                                |
+| 토큰             | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (setup에서 선택) |
 | 캐시 디렉터리    | `~/.kiwoom/cache/`                       |
 | 운영 도메인      | `https://api.kiwoom.com`                 |
 | 모의투자 도메인  | `https://mockapi.kiwoom.com`             |

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli/__init__.py

@@ -1,3 +1,3 @@
 """Kiwoom Securities REST API CLI."""
 
-__version__ = "2.1.1"
+__version__ = "2.2.1"

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli/auth.py

@@ -3,10 +3,19 @@
 Tokens are stored in the OS keychain (plain, not encrypted).
 Tokens are short-lived and can be re-issued, so the security risk
 of plain keychain storage is low compared to appkey/secretkey.
+
+KIWOOM_TOKEN 환경변수가 설정되어 있으면 키체인보다 우선합니다. 키체인에
+접근할 수 없는 샌드박스/CI/AI 에이전트 환경을 위한 통로로, 만료되는
+토큰만 허용됩니다 — appkey/secretkey는 여전히 환경변수를 지원하지 않습니다.
+
+프로필의 token_storage가 "env"이면 save_token은 키체인에 쓰지 않습니다.
+auth login이 토큰을 출력하고, 사용자가 KIWOOM_TOKEN으로 직접 관리합니다.
 """
 
 from __future__ import annotations
 
+import os
+
 import keyring
 
 from . import config
@@ -16,10 +25,15 @@ KEYRING_SERVICE = config.KEYRING_SERVICE
 
 def save_token(token: str, profile: str | None = None) -> None:
     p = config.resolve_profile(profile)
+    if config.get_token_storage(p) == "env":
+        return
     keyring.set_password(KEYRING_SERVICE, f"{p}:token", token)
 
 
 def load_token(profile: str | None = None) -> str | None:
+    env = os.environ.get("KIWOOM_TOKEN")
+    if env:
+        return env
     p = config.resolve_profile(profile)
     return config._keyring_get(f"{p}:token")
 

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli/client.py

@@ -24,6 +24,10 @@ class KiwoomAPIError(Exception):
         super().__init__(f"[{code}] {msg}")
 
 
+class KiwoomAuthError(Exception):
+    """No access token available — the caller must authenticate first."""
+
+
 class KiwoomClient:
     """Synchronous client for the Kiwoom REST API."""
 
@@ -80,6 +84,8 @@ class KiwoomClient:
         next_key: str = "",
     ) -> tuple[dict[str, Any], dict[str, str]]:
         """Make a single API request. Returns (body_json, response_headers)."""
+        if not self.token:
+            raise KiwoomAuthError()
         url_path = get_url(api_id)
         headers = self._headers(api_id, cont_yn, next_key)
         if self._should_spin():

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli/config.py

@@ -7,7 +7,9 @@ keychain via keyring (macOS Keychain / Windows Credential Manager /
 Linux Secret Service). The keychain encrypts secrets at rest; no
 app-level password is required — commands never prompt.
 
-Non-sensitive settings (domain, account) remain in config.toml.
+Non-sensitive settings (domain, account, token_storage) remain in config.toml.
+token_storage: "keychain" (기본, auth login이 토큰을 키체인에 저장) 또는
+"env" (키체인에 저장하지 않음 — 사용자가 KIWOOM_TOKEN 환경변수로 직접 관리).
 
 Environment variables (non-sensitive only):
   KIWOOM_DOMAIN       도메인 (prod / mock)
@@ -19,6 +21,7 @@ Config file: ~/.kiwoom/config.toml
 
 from __future__ import annotations
 
+import copy
 import os
 import sys
 from pathlib import Path
@@ -42,6 +45,8 @@ DOMAINS = {
     "mock": "https://mockapi.kiwoom.com",
 }
 
+TOKEN_STORAGES = ("keychain", "env")
+
 DEFAULT_CONFIG = {
     "general": {"default_profile": "default"},
     "profiles": {"default": {"domain": "mock", "account": ""}},
@@ -57,7 +62,8 @@ def ensure_cache_dir() -> None:
 
 def load_config() -> dict:
     if not CONFIG_FILE.exists():
-        return dict(DEFAULT_CONFIG)
+        # deepcopy: 호출자가 중첩 dict를 수정해도 DEFAULT_CONFIG가 오염되지 않도록
+        return copy.deepcopy(DEFAULT_CONFIG)
     with open(CONFIG_FILE, "rb") as f:
         return tomllib.load(f)
 
@@ -167,6 +173,14 @@ def set_secretkey(value: str, profile: str | None = None) -> None:
     keyring.set_password(KEYRING_SERVICE, f"{p}:secretkey", value)
 
 
+def get_token_storage(profile: str | None = None) -> str:
+    """토큰 저장 방식: "keychain" (OS 키체인) 또는 "env" (KIWOOM_TOKEN 직접 관리)."""
+    p = resolve_profile(profile)
+    cfg = load_config()
+    value = cfg.get("profiles", {}).get(p, {}).get("token_storage", "keychain")
+    return value if value in TOKEN_STORAGES else "keychain"
+
+
 def get_account(profile: str | None = None) -> str:
     env = os.environ.get("KIWOOM_ACCOUNT")
     if env:

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli/main.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 import json
+import os
 
 import click
 import httpx
+import keyring
 
 from . import __version__, auth, config
-from .client import KiwoomClient, KiwoomAPIError
+from .client import KiwoomClient, KiwoomAPIError, KiwoomAuthError
 from .commands.account import account
 from .commands.dashboard import dashboard
 from .commands.market import market
@@ -44,6 +46,21 @@ class KiwoomGroup(click.Group):
             else:
                 console.print(f"[red]API 오류:[/] {e}")
             ctx.exit(EXIT_API)
+        except KiwoomAuthError:
+            fmt = ctx.obj.get("format", "table") if ctx.obj else "table"
+            msg = "토큰이 없습니다. 'kiwoom auth login'으로 발급하세요."
+            if fmt == "json":
+                click.echo(json.dumps({"error": msg, "code": "auth_required"}, ensure_ascii=False))
+            else:
+                console.print("[red]인증 필요:[/] 토큰이 없습니다. [dim]kiwoom auth login[/]")
+            ctx.exit(EXIT_AUTH)
+        except keyring.errors.KeyringError:
+            console.print("[red]키체인 오류:[/] OS 키체인에 접근할 수 없습니다 (잠김 또는 비대화형 세션).")
+            console.print(
+                "[dim]키체인 없는 환경에서는 본인 터미널에서 토큰을 발급한 뒤 "
+                "KIWOOM_TOKEN 환경변수로 전달하세요. (README '샌드박스 환경' 참고)[/]"
+            )
+            ctx.exit(EXIT_INPUT)
         except httpx.HTTPStatusError as e:
             if e.response.status_code == 401:
                 console.print("[red]인증 오류:[/] 토큰이 만료되었습니다. [dim]kiwoom auth login[/]")
@@ -122,7 +139,11 @@ def config_cmd():
 @click.option("--secretkey", prompt="Secret Key", hide_input=True, help="키움 API Secret Key")
 @click.option("--domain", prompt="도메인 (prod=실거래, mock=모의투자)", type=click.Choice(["prod", "mock"]), default="mock", help="도메인")
 @click.option("--account", prompt="계좌번호 (없으면 Enter)", default="", help="계좌번호")
-def config_setup(profile: str, appkey: str, secretkey: str, domain: str, account: str):
+@click.option("--token-storage", "token_storage",
+              prompt="토큰 저장 방식 (keychain=OS 키체인, env=KIWOOM_TOKEN 직접 관리)",
+              type=click.Choice(list(config.TOKEN_STORAGES)), default="keychain",
+              help="접근토큰 저장 방식")
+def config_setup(profile: str, appkey: str, secretkey: str, domain: str, account: str, token_storage: str):
     """초기 설정 (App Key, Secret Key, 도메인)."""
     if config.is_legacy_encrypted():
         # Old password-encrypted entries are unusable — purge before writing new keys
@@ -134,6 +155,7 @@ def config_setup(profile: str, appkey: str, secretkey: str, domain: str, account
     cfg.setdefault("profiles", {}).setdefault(profile, {})["domain"] = domain
     if account:
         cfg["profiles"][profile]["account"] = account
+    cfg["profiles"][profile]["token_storage"] = token_storage
     if "default_profile" not in cfg.get("general", {}):
         cfg.setdefault("general", {})["default_profile"] = profile
     cfg.pop("auth", None)
@@ -141,6 +163,10 @@ def config_setup(profile: str, appkey: str, secretkey: str, domain: str, account
     console.print(f"[green]설정 완료![/] (프로필: {profile})")
     console.print("  App Key/Secret Key: [bold]OS 키체인에 저장됨[/]")
     console.print(f"  도메인: [bold]{config.DOMAINS[domain]}[/]")
+    if token_storage == "env":
+        console.print("  토큰 저장: [bold]환경변수 (KIWOOM_TOKEN)[/] — auth login 후 안내되는 export를 실행하세요")
+    else:
+        console.print("  토큰 저장: [bold]OS 키체인[/]")
 
 
 @config_cmd.command("show")
@@ -151,6 +177,7 @@ def config_show(ctx):
     cfg = config.load_config()
     configured = config.is_configured(profile)
     profile_cfg = cfg.get("profiles", {}).get(profile, {})
+    token_storage = config.get_token_storage(profile)
     if _get_format() == "json":
         _output_json({
             "profile": profile,
@@ -158,6 +185,7 @@ def config_show(ctx):
             "domain": profile_cfg.get("domain", "mock"),
             "configured": configured,
             "account": profile_cfg.get("account", ""),
+            "token_storage": token_storage,
         })
         return
     human(f"  프로필: [bold]{profile}[/]")
@@ -165,11 +193,12 @@ def config_show(ctx):
     human(f"  도메인: {profile_cfg.get('domain', 'mock')}")
     human(f"  App Key: {'[dim]설정됨 (키체인)[/]' if configured else '(미설정)'}")
     human(f"  계좌번호: {profile_cfg.get('account', '(미설정)')}")
+    human(f"  토큰 저장: {'환경변수 (KIWOOM_TOKEN)' if token_storage == 'env' else 'OS 키체인'}")
     human(f"  보안: [bold]{'OS 키체인 저장' if configured else '미설정'}[/]")
 
 
 @config_cmd.command("set")
-@click.argument("key", type=click.Choice(["domain", "account"]))
+@click.argument("key", type=click.Choice(["domain", "account", "token_storage"]))
 @click.argument("value")
 @click.pass_context
 def config_set(ctx, key: str, value: str):
@@ -178,6 +207,9 @@ def config_set(ctx, key: str, value: str):
     if key == "domain" and value not in ("prod", "mock"):
         console.print("[red]domain은 prod 또는 mock만 가능합니다.[/]")
         raise SystemExit(1)
+    if key == "token_storage" and value not in config.TOKEN_STORAGES:
+        console.print("[red]token_storage는 keychain 또는 env만 가능합니다.[/]")
+        raise SystemExit(1)
     cfg = config.load_config()
     cfg.setdefault("profiles", {}).setdefault(profile, {})[key] = value
     config.save_config(cfg)
@@ -243,10 +275,14 @@ def auth_login(ctx):
     with KiwoomClient() as c:
         try:
             token = c.issue_token()
-            masked = token[:10] + "..." + token[-4:] if len(token) > 14 else token
             human("[green]토큰 발급 완료![/]")
-            human(f"  토큰: {masked}")
-            human("  저장 위치: [bold]키체인[/]")
+            if config.get_token_storage(profile) == "env":
+                human("  저장 위치: [bold]없음 (env 모드)[/] — 아래를 셸에서 실행하세요:")
+                human(f"  export KIWOOM_TOKEN='{token}'")
+            else:
+                masked = token[:10] + "..." + token[-4:] if len(token) > 14 else token
+                human(f"  토큰: {masked}")
+                human("  저장 위치: [bold]키체인[/]")
         except KiwoomAPIError as e:
             human(f"[red]토큰 발급 실패:[/] {e}")
 
@@ -265,6 +301,8 @@ def auth_logout(ctx):
             human("[green]토큰 폐기 완료.[/]")
         except KiwoomAPIError as e:
             human(f"[red]토큰 폐기 실패:[/] {e}")
+    if os.environ.get("KIWOOM_TOKEN"):
+        human("[yellow]KIWOOM_TOKEN 환경변수가 설정되어 있어 이 셸에서는 해당 토큰이 계속 사용됩니다. unset KIWOOM_TOKEN 으로 제거하세요.[/]")
 
 
 @auth_cmd.command("status")
@@ -273,22 +311,31 @@ def auth_status(ctx):
     """토큰 상태 확인."""
     profile = config.resolve_profile(ctx.obj.get("profile") if ctx.obj else None)
     configured = config.is_configured(profile)
-    has_token = configured and auth.load_token(profile=profile) is not None
+    token_storage = config.get_token_storage(profile)
+    token = auth.load_token(profile=profile)
+    token_source = None
+    if token is not None:
+        token_source = "env" if os.environ.get("KIWOOM_TOKEN") else "keyring"
     if _get_format() == "json":
         cfg = config.load_config()
         _output_json({
             "profile": profile,
             "domain": cfg.get("profiles", {}).get(profile, {}).get("domain", "mock"),
             "configured": configured,
-            "has_token": has_token,
+            "has_token": token is not None,
+            "token_source": token_source,
+            "token_storage": token_storage,
         })
         return
-    if not configured:
+    if not configured and token is None:
         human("[yellow]설정 필요.[/] 'kiwoom config setup' 으로 설정하세요.")
         return
     human(f"  프로필: [bold]{profile}[/]")
-    if has_token:
-        human("[green]토큰 있음[/] [dim](키체인 저장됨)[/]")
+    if token is not None:
+        source_label = "환경변수 KIWOOM_TOKEN" if token_source == "env" else "키체인 저장됨"
+        human(f"[green]토큰 있음[/] [dim]({source_label})[/]")
+    elif token_storage == "env":
+        human("[yellow]토큰 없음.[/] 'kiwoom auth login' 으로 발급 후 안내되는 export KIWOOM_TOKEN을 실행하세요.")
     else:
         human("[yellow]토큰 없음.[/] 'kiwoom auth login' 으로 발급하세요.")
 

{kiwoom_cli-2.1.1 → kiwoom_cli-2.2.1}/kiwoom_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwoom-cli
-Version: 2.1.1
+Version: 2.2.1
 Summary: User-friendly CLI for the Kiwoom Securities REST API (키움증권)
 License: LicenseRef-kiwoom-cli-Source-Available-1.0
 Project-URL: Homepage, https://github.com/gejyn14/kiwoom-cli
@@ -84,6 +84,7 @@ $ kiwoom -f json account balance | jq       # AI 에이전트·스크립트 친
 
 ```bash
 # 1. 초기 설정 (appkey, secretkey → OS 키체인)
+#    토큰 저장 방식도 여기서 선택: keychain (기본) 또는 env (KIWOOM_TOKEN 직접 관리)
 kiwoom config setup
 
 # 2. 토큰 발급
@@ -108,14 +109,25 @@ kiwoom config show          # 현재 설정 확인
 
 ### 환경변수 설정
 
-도메인과 계좌번호는 환경변수로도 설정 가능합니다.
+도메인, 계좌번호, 프로필, 토큰은 환경변수로도 설정 가능합니다.
 
 ```bash
 export KIWOOM_DOMAIN="prod"       # prod 또는 mock
 export KIWOOM_ACCOUNT="1234567"   # 선택
+export KIWOOM_PROFILE="isa"       # 선택
+export KIWOOM_TOKEN="..."         # 선택: 키체인 대신 사용할 접근토큰 (샌드박스/CI용)
 ```
 
-appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요.
+appkey/secretkey는 보안을 위해 환경변수를 지원하지 않습니다. 반드시 `kiwoom config setup`으로 OS 키체인에 저장하세요. `KIWOOM_TOKEN`은 만료·폐기 가능한 접근토큰만 담는 통로로, 키체인에 접근할 수 없는 환경(샌드박스, CI, AI 에이전트)에서 사용합니다 — 설정 시 키체인 토큰보다 우선합니다.
+
+### 토큰 저장 방식 (keychain vs env)
+
+`config setup`에서 토큰 저장 방식을 선택합니다.
+
+- **keychain** (기본): `auth login`이 토큰을 OS 키체인에 저장합니다. 본인 터미널에서 쓰는 일반적인 방식.
+- **env**: 토큰을 키체인에 저장하지 않습니다. `auth login`이 토큰과 `export KIWOOM_TOKEN=...` 명령을 출력하면 셸에서 실행하세요. 키체인 접근이 불가능한 환경(샌드박스, CI, 컨테이너)이 주 작업 환경일 때 적합합니다.
+
+이후 전환은 `kiwoom config set token_storage keychain|env`.
 
 ### 멀티 프로필
 
@@ -160,6 +172,26 @@ kiwoom order buy 005930 10 --type market --confirm
 - 페이지네이션(연속조회)은 자동 처리 — 에이전트가 커서를 관리할 필요가 없습니다.
 - 자세한 패턴은 [Wiki: AI 에이전트 가이드](https://github.com/gejyn14/kiwoom-cli/wiki/AI-Agents) 참고.
 
+### 샌드박스 환경 (키체인 접근 불가)
+
+샌드박스 셸, CI, 컨테이너에서는 OS 키체인을 읽을 수 없습니다. 이때는 본인 터미널에서 토큰을 발급받아 `KIWOOM_TOKEN`으로 전달하세요 — appkey/secretkey는 키체인 밖으로 나가지 않고, 토큰은 만료·폐기 가능합니다.
+
+```bash
+# 본인 터미널에서 (하루 1회 정도) — env 모드라면 login이 export 명령을 그대로 출력
+kiwoom config set token_storage env
+kiwoom auth login
+export KIWOOM_TOKEN='...'   # login 출력의 export 라인을 복사해 실행
+
+# 이 셸에서 에이전트를 실행하면 환경변수가 상속되어 모든 명령이 동작
+kiwoom auth status   # 토큰 있음 (환경변수 KIWOOM_TOKEN)
+```
+
+keychain 모드를 유지하면서 일회성으로 꺼내 쓰려면:
+
+```bash
+export KIWOOM_TOKEN=$(security find-generic-password -s kiwoom-cli -a "default:token" -w)  # macOS
+```
+
 ## 명령어 구조
 
 ```
@@ -513,11 +545,11 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 모든 인증정보(appkey, secretkey, 토큰)는 **OS 키체인**(macOS Keychain / Windows Credential Manager / Linux Secret Service)에 저장됩니다. 파일로 존재하지 않으며, 키체인이 디스크 저장 시 암호화를 담당합니다. `gh`, `aws`, `docker` CLI와 동일한 모델입니다.
 
-| 항목               | 저장 방식          | 프롬프트 |
-| ------------------ | ------------------ | :------: |
-| appkey / secretkey | OS 키체인          |    X     |
-| 토큰               | OS 키체인          |    X     |
-| config.toml        | 도메인, 계좌번호만 |    X     |
+| 항목               | 저장 방식                                  | 프롬프트 |
+| ------------------ | ------------------------------------------ | :------: |
+| appkey / secretkey | OS 키체인                                  |    X     |
+| 토큰               | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (선택) |    X     |
+| config.toml        | 도메인, 계좌번호, 토큰 저장 방식만         |    X     |
 
 - 모든 명령어는 비밀번호/생체인증 프롬프트 없이 동작 (AI 에이전트·자동화 친화적)
 - 앱 자체 암호화 계층은 의도적으로 두지 않음 — 추가 계층은 명령마다 잠금 해제 프롬프트를 요구하게 되어 CLI 사용성을 해침
@@ -530,9 +562,9 @@ eval (env _KIWOOM_COMPLETE=fish_source kiwoom)
 
 | 항목             | 값                                       |
 | ---------------- | ---------------------------------------- |
-| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌만) |
+| 설정 파일        | `~/.kiwoom/config.toml` (도메인, 계좌, 토큰 저장 방식만) |
 | appkey/secretkey | OS 키체인                                |
-| 토큰             | OS 키체인                                |
+| 토큰             | OS 키체인 또는 KIWOOM_TOKEN 환경변수 (setup에서 선택) |
 | 캐시 디렉터리    | `~/.kiwoom/cache/`                       |
 | 운영 도메인      | `https://api.kiwoom.com`                 |
 | 모의투자 도메인  | `https://mockapi.kiwoom.com`             |

kiwoom_cli-2.2.1/tests/test_auth.py

@@ -0,0 +1,64 @@
+"""Tests for kiwoom_cli.auth — keyring-backed token storage."""
+
+import keyring
+
+from kiwoom_cli import auth
+
+
+def test_save_token_stores_in_keyring():
+    auth.save_token("abc123", profile="test-profile")
+    assert keyring.get_password(auth.KEYRING_SERVICE, "test-profile:token") == "abc123"
+
+
+def test_load_token_returns_stored_value():
+    auth.save_token("xyz789", profile="test-profile")
+    assert auth.load_token(profile="test-profile") == "xyz789"
+
+
+def test_load_token_returns_none_when_missing():
+    assert auth.load_token(profile="nonexistent") is None
+
+
+def test_delete_token_removes_stored_value():
+    auth.save_token("to-delete", profile="test-profile")
+    assert auth.load_token(profile="test-profile") == "to-delete"
+    auth.delete_token(profile="test-profile")
+    assert auth.load_token(profile="test-profile") is None
+
+
+def test_delete_token_missing_key_is_noop():
+    auth.delete_token(profile="never-existed")  # must not raise
+
+
+# ── KIWOOM_TOKEN 환경변수 ────────────────────────────
+# 키체인에 접근할 수 없는 샌드박스/CI/AI 에이전트 환경용 통로.
+# appkey/secretkey는 여전히 환경변수 미지원.
+
+
+def test_load_token_env_var_takes_precedence(monkeypatch):
+    auth.save_token("keyring-token", profile="test-profile")
+    monkeypatch.setenv("KIWOOM_TOKEN", "env-token")
+    assert auth.load_token(profile="test-profile") == "env-token"
+
+
+def test_load_token_env_var_works_without_keyring(monkeypatch):
+    """잠긴 키체인에서도 KIWOOM_TOKEN이면 토큰 확보."""
+
+    def _raise(svc, key):
+        raise keyring.errors.KeyringError("errSecInteractionNotAllowed (-25308)")
+
+    monkeypatch.setattr(keyring, "get_password", _raise)
+    monkeypatch.setenv("KIWOOM_TOKEN", "env-token")
+    assert auth.load_token(profile="default") == "env-token"
+
+
+def test_load_token_falls_back_to_keyring_when_env_unset(monkeypatch):
+    monkeypatch.delenv("KIWOOM_TOKEN", raising=False)
+    auth.save_token("keyring-token", profile="test-profile")
+    assert auth.load_token(profile="test-profile") == "keyring-token"
+
+
+def test_load_token_empty_env_var_is_ignored(monkeypatch):
+    monkeypatch.setenv("KIWOOM_TOKEN", "")
+    auth.save_token("keyring-token", profile="test-profile")
+    assert auth.load_token(profile="test-profile") == "keyring-token"

kiwoom_cli-2.2.1/tests/test_auth_cli.py

@@ -0,0 +1,292 @@
+"""CLI-level tests: no password prompts anywhere after keychain-only change."""
+
+from __future__ import annotations
+
+import keyring
+import pytest
+from click.testing import CliRunner
+
+from kiwoom_cli import config
+from kiwoom_cli.main import cli
+
+
+@pytest.fixture(autouse=True)
+def mem_keyring(monkeypatch):
+    data: dict[str, str] = {}
+    monkeypatch.setattr(keyring, "get_password", lambda svc, key: data.get(f"{svc}:{key}"))
+    monkeypatch.setattr(keyring, "set_password", lambda svc, key, val: data.__setitem__(f"{svc}:{key}", val))
+
+    def _delete(svc, key):
+        if f"{svc}:{key}" not in data:
+            raise keyring.errors.PasswordDeleteError(key)
+        del data[f"{svc}:{key}"]
+
+    monkeypatch.setattr(keyring, "delete_password", _delete)
+    return data
+
+
+@pytest.fixture(autouse=True)
+def isolated_config(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.toml")
+    return tmp_path
+
+
+def test_config_setup_no_password_prompt(mem_keyring):
+    """setup succeeds with only appkey/secretkey/domain/account inputs."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        ["config", "setup"],
+        input="my-appkey\nmy-secretkey\nmock\n\n\n",
+    )
+    assert result.exit_code == 0, result.output
+    assert "비밀번호" not in result.output
+    assert mem_keyring[f"{config.KEYRING_SERVICE}:default:appkey"] == "my-appkey"
+    assert mem_keyring[f"{config.KEYRING_SERVICE}:default:secretkey"] == "my-secretkey"
+    # Enter만 치면 기본값 keychain
+    assert config.get_token_storage("default") == "keychain"
+
+
+def test_config_setup_purges_legacy_format(mem_keyring):
+    """setup clears _salt/_verify and old ciphertext entries."""
+    keyring.set_password(config.KEYRING_SERVICE, "_salt", "oldsalt")
+    keyring.set_password(config.KEYRING_SERVICE, "_verify", "oldverify")
+    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "gAAAA-cipher")
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        ["config", "setup"],
+        input="new-appkey\nnew-secretkey\nmock\n\n\n",
+    )
+    assert result.exit_code == 0, result.output
+    assert keyring.get_password(config.KEYRING_SERVICE, "_salt") is None
+    assert keyring.get_password(config.KEYRING_SERVICE, "_verify") is None
+    assert config.get_appkey(profile="default") == "new-appkey"
+
+
+def test_auth_login_no_password_prompt(monkeypatch, mem_keyring):
+    """auth login issues a token without any interactive prompt."""
+    from kiwoom_cli import client as client_mod
+
+    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "ak")
+    keyring.set_password(config.KEYRING_SERVICE, "default:secretkey", "sk")
+
+    monkeypatch.setattr(
+        client_mod.KiwoomClient, "issue_token", lambda self: "issued-token-value-12345"
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["auth", "login"], input="")
+    assert result.exit_code == 0, result.output
+    assert "비밀번호" not in result.output
+    assert "토큰 발급 완료" in result.output
+
+
+def test_auth_login_unconfigured_tells_user_to_setup(mem_keyring):
+    runner = CliRunner()
+    result = runner.invoke(cli, ["auth", "login"])
+    assert result.exit_code != 0
+    assert "config setup" in result.output
+
+
+def test_legacy_format_shows_resetup_notice(mem_keyring):
+    """Any command under legacy format prints the re-setup notice."""
+    keyring.set_password(config.KEYRING_SERVICE, "_salt", "oldsalt")
+    runner = CliRunner()
+    result = runner.invoke(cli, ["auth", "status"])
+    assert "kiwoom config setup" in result.output or "config setup" in result.output
+
+
+def test_readonly_commands_survive_broken_keyring(monkeypatch):
+    """Locked/absent keychain (headless, CI): config show / auth status must
+    exit 0 as "미설정" instead of crashing with a KeyringError traceback."""
+
+    def _raise(svc, key):
+        raise keyring.errors.KeyringError("errSecInteractionNotAllowed (-25308)")
+
+    monkeypatch.setattr(keyring, "get_password", _raise)
+    runner = CliRunner()
+
+    for argv in (["config", "show"], ["auth", "status"], ["config", "profiles"]):
+        result = runner.invoke(cli, argv)
+        assert result.exit_code == 0, (argv, result.exception)
+
+
+# ── token_storage: keychain vs env (config setup에서 선택) ──────────
+
+
+def test_config_setup_env_storage_choice(mem_keyring):
+    """setup에서 env를 고르면 token_storage=env가 프로필에 저장된다."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        ["config", "setup"],
+        input="my-appkey\nmy-secretkey\nmock\n\nenv\n",
+    )
+    assert result.exit_code == 0, result.output
+    assert config.get_token_storage("default") == "env"
+    assert "KIWOOM_TOKEN" in result.output
+
+
+def test_auth_login_env_storage_prints_export_and_skips_keyring(monkeypatch, mem_keyring):
+    """env 모드: 토큰을 키체인에 저장하지 않고 export 안내를 출력한다."""
+    from kiwoom_cli import auth
+    from kiwoom_cli.client import KiwoomClient as RealClient
+
+    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "ak")
+    keyring.set_password(config.KEYRING_SERVICE, "default:secretkey", "sk")
+    cfg = config.load_config()
+    cfg.setdefault("profiles", {}).setdefault("default", {})["token_storage"] = "env"
+    config.save_config(cfg)
+
+    def _issue(self):
+        auth.save_token("issued-token-value-12345", profile=self.profile)
+        return "issued-token-value-12345"
+
+    monkeypatch.setattr(RealClient, "issue_token", _issue)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["auth", "login"])
+    assert result.exit_code == 0, result.output
+    assert "export KIWOOM_TOKEN='issued-token-value-12345'" in result.output
+    assert f"{config.KEYRING_SERVICE}:default:token" not in mem_keyring
+
+
+def test_auth_login_keychain_storage_saves_to_keyring(monkeypatch, mem_keyring):
+    """keychain 모드(기본): 토큰이 키체인에 저장되고 마스킹되어 출력된다."""
+    from kiwoom_cli import auth
+    from kiwoom_cli.client import KiwoomClient as RealClient
+
+    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "ak")
+    keyring.set_password(config.KEYRING_SERVICE, "default:secretkey", "sk")
+
+    def _issue(self):
+        auth.save_token("issued-token-value-12345", profile=self.profile)
+        return "issued-token-value-12345"
+
+    monkeypatch.setattr(RealClient, "issue_token", _issue)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["auth", "login"])
+    assert result.exit_code == 0, result.output
+    assert "issued-token-value-12345" not in result.output  # full token never shown
+    assert mem_keyring[f"{config.KEYRING_SERVICE}:default:token"] == "issued-token-value-12345"
+
+
+def test_config_set_token_storage(mem_keyring):
+    """config set token_storage env/keychain 으로 전환 가능."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["config", "set", "token_storage", "env"])
+    assert result.exit_code == 0, result.output
+    assert config.get_token_storage("default") == "env"
+
+    result = runner.invoke(cli, ["config", "set", "token_storage", "keychain"])
+    assert result.exit_code == 0, result.output
+    assert config.get_token_storage("default") == "keychain"
+
+
+def test_config_set_token_storage_rejects_bad_value(mem_keyring):
+    runner = CliRunner()
+    result = runner.invoke(cli, ["config", "set", "token_storage", "file"])
+    assert result.exit_code == 1
+
+
+def test_auth_status_shows_env_storage_mode(mem_keyring):
+    """env 모드 + 토큰 없음: status가 export 안내를 보여준다."""
+    import json as _json
+
+    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "ak")
+    cfg = config.load_config()
+    cfg.setdefault("profiles", {}).setdefault("default", {})["token_storage"] = "env"
+    config.save_config(cfg)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["-f", "json", "auth", "status"])
+    assert result.exit_code == 0
+    doc = _json.loads(result.stdout)
+    assert doc["token_storage"] == "env"
+    assert doc["has_token"] is False
+
+    result = runner.invoke(cli, ["auth", "status"])
+    assert result.exit_code == 0
+    assert "KIWOOM_TOKEN" in result.output
+
+
+def test_auth_status_reflects_env_token_with_broken_keyring(monkeypatch):
+    """샌드박스(잠긴 키체인) + KIWOOM_TOKEN: auth status가 토큰을 인식해야 한다."""
+    import json as _json
+
+    def _raise(svc, key):
+        raise keyring.errors.KeyringError("errSecInteractionNotAllowed (-25308)")
+
+    monkeypatch.setattr(keyring, "get_password", _raise)
+    monkeypatch.setenv("KIWOOM_TOKEN", "env-token")
+    runner = CliRunner()
+
+    result = runner.invoke(cli, ["-f", "json", "auth", "status"])
+    assert result.exit_code == 0
+    doc = _json.loads(result.stdout)
+    assert doc["has_token"] is True
+    assert doc["token_source"] == "env"
+
+    result = runner.invoke(cli, ["auth", "status"])
+    assert result.exit_code == 0
+    assert "KIWOOM_TOKEN" in result.output
+
+
+# ── 키체인 쓰기 실패 / 토큰 부재 처리 ─────────────────────
+
+
+def test_config_setup_keychain_write_failure_friendly_error(monkeypatch, mem_keyring):
+    """키체인 쓰기 불가(-25308 등): traceback 대신 친절한 안내 + exit 1."""
+
+    def _locked(svc, key, val):
+        raise keyring.errors.KeyringError("errSecInteractionNotAllowed (-25308)")
+
+    monkeypatch.setattr(keyring, "set_password", _locked)
+    runner = CliRunner()
+    result = runner.invoke(
+        cli, ["config", "setup"], input="ak\nsk\nmock\n\n\n"
+    )
+    assert result.exit_code == 1, result.output
+    # 예외가 새어나오지 않고 CLI가 스스로 종료해야 한다
+    assert result.exception is None or isinstance(result.exception, SystemExit)
+    combined = result.output + result.stderr
+    assert "키체인" in combined
+    assert "KIWOOM_TOKEN" in combined
+
+
+def test_missing_token_exits_3_before_any_request(monkeypatch, mem_keyring):
+    """토큰이 전혀 없으면 요청을 보내지 않고 exit 3 + auth login 힌트."""
+    import httpx
+
+    monkeypatch.delenv("KIWOOM_TOKEN", raising=False)
+
+    def _no_network(*args, **kwargs):
+        raise AssertionError("token 없이 HTTP 요청이 나가면 안 된다")
+
+    monkeypatch.setattr(httpx.Client, "post", _no_network)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["stock", "info", "005930"])
+    assert result.exit_code == 3, result.output
+    assert "auth login" in result.output + result.stderr
+
+
+def test_missing_token_json_mode_single_json_error_doc(monkeypatch, mem_keyring):
+    """-f json + 토큰 부재: stdout은 단일 JSON 에러 문서, exit 3."""
+    import json as _json
+
+    import httpx
+
+    monkeypatch.delenv("KIWOOM_TOKEN", raising=False)
+    monkeypatch.setattr(
+        httpx.Client, "post",
+        lambda *a, **k: (_ for _ in ()).throw(AssertionError("no request expected")),
+    )
+    runner = CliRunner()
+    result = runner.invoke(cli, ["-f", "json", "stock", "info", "005930"])
+    assert result.exit_code == 3, result.output
+    doc = _json.loads(result.stdout)
+    assert "error" in doc

kiwoom_cli-2.1.1/tests/test_auth.py

@@ -1,30 +0,0 @@
-"""Tests for kiwoom_cli.auth — keyring-backed token storage."""
-
-import keyring
-
-from kiwoom_cli import auth
-
-
-def test_save_token_stores_in_keyring():
-    auth.save_token("abc123", profile="test-profile")
-    assert keyring.get_password(auth.KEYRING_SERVICE, "test-profile:token") == "abc123"
-
-
-def test_load_token_returns_stored_value():
-    auth.save_token("xyz789", profile="test-profile")
-    assert auth.load_token(profile="test-profile") == "xyz789"
-
-
-def test_load_token_returns_none_when_missing():
-    assert auth.load_token(profile="nonexistent") is None
-
-
-def test_delete_token_removes_stored_value():
-    auth.save_token("to-delete", profile="test-profile")
-    assert auth.load_token(profile="test-profile") == "to-delete"
-    auth.delete_token(profile="test-profile")
-    assert auth.load_token(profile="test-profile") is None
-
-
-def test_delete_token_missing_key_is_noop():
-    auth.delete_token(profile="never-existed")  # must not raise

kiwoom_cli-2.1.1/tests/test_auth_cli.py

@@ -1,112 +0,0 @@
-"""CLI-level tests: no password prompts anywhere after keychain-only change."""
-
-from __future__ import annotations
-
-import keyring
-import pytest
-from click.testing import CliRunner
-
-from kiwoom_cli import config
-from kiwoom_cli.main import cli
-
-
-@pytest.fixture(autouse=True)
-def mem_keyring(monkeypatch):
-    data: dict[str, str] = {}
-    monkeypatch.setattr(keyring, "get_password", lambda svc, key: data.get(f"{svc}:{key}"))
-    monkeypatch.setattr(keyring, "set_password", lambda svc, key, val: data.__setitem__(f"{svc}:{key}", val))
-
-    def _delete(svc, key):
-        if f"{svc}:{key}" not in data:
-            raise keyring.errors.PasswordDeleteError(key)
-        del data[f"{svc}:{key}"]
-
-    monkeypatch.setattr(keyring, "delete_password", _delete)
-    return data
-
-
-@pytest.fixture(autouse=True)
-def isolated_config(tmp_path, monkeypatch):
-    monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
-    monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.toml")
-    return tmp_path
-
-
-def test_config_setup_no_password_prompt(mem_keyring):
-    """setup succeeds with only appkey/secretkey/domain/account inputs."""
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        ["config", "setup"],
-        input="my-appkey\nmy-secretkey\nmock\n\n",
-    )
-    assert result.exit_code == 0, result.output
-    assert "비밀번호" not in result.output
-    assert mem_keyring[f"{config.KEYRING_SERVICE}:default:appkey"] == "my-appkey"
-    assert mem_keyring[f"{config.KEYRING_SERVICE}:default:secretkey"] == "my-secretkey"
-
-
-def test_config_setup_purges_legacy_format(mem_keyring):
-    """setup clears _salt/_verify and old ciphertext entries."""
-    keyring.set_password(config.KEYRING_SERVICE, "_salt", "oldsalt")
-    keyring.set_password(config.KEYRING_SERVICE, "_verify", "oldverify")
-    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "gAAAA-cipher")
-
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        ["config", "setup"],
-        input="new-appkey\nnew-secretkey\nmock\n\n",
-    )
-    assert result.exit_code == 0, result.output
-    assert keyring.get_password(config.KEYRING_SERVICE, "_salt") is None
-    assert keyring.get_password(config.KEYRING_SERVICE, "_verify") is None
-    assert config.get_appkey(profile="default") == "new-appkey"
-
-
-def test_auth_login_no_password_prompt(monkeypatch, mem_keyring):
-    """auth login issues a token without any interactive prompt."""
-    from kiwoom_cli import client as client_mod
-
-    keyring.set_password(config.KEYRING_SERVICE, "default:appkey", "ak")
-    keyring.set_password(config.KEYRING_SERVICE, "default:secretkey", "sk")
-
-    monkeypatch.setattr(
-        client_mod.KiwoomClient, "issue_token", lambda self: "issued-token-value-12345"
-    )
-
-    runner = CliRunner()
-    result = runner.invoke(cli, ["auth", "login"], input="")
-    assert result.exit_code == 0, result.output
-    assert "비밀번호" not in result.output
-    assert "토큰 발급 완료" in result.output
-
-
-def test_auth_login_unconfigured_tells_user_to_setup(mem_keyring):
-    runner = CliRunner()
-    result = runner.invoke(cli, ["auth", "login"])
-    assert result.exit_code != 0
-    assert "config setup" in result.output
-
-
-def test_legacy_format_shows_resetup_notice(mem_keyring):
-    """Any command under legacy format prints the re-setup notice."""
-    keyring.set_password(config.KEYRING_SERVICE, "_salt", "oldsalt")
-    runner = CliRunner()
-    result = runner.invoke(cli, ["auth", "status"])
-    assert "kiwoom config setup" in result.output or "config setup" in result.output
-
-
-def test_readonly_commands_survive_broken_keyring(monkeypatch):
-    """Locked/absent keychain (headless, CI): config show / auth status must
-    exit 0 as "미설정" instead of crashing with a KeyringError traceback."""
-
-    def _raise(svc, key):
-        raise keyring.errors.KeyringError("errSecInteractionNotAllowed (-25308)")
-
-    monkeypatch.setattr(keyring, "get_password", _raise)
-    runner = CliRunner()
-
-    for argv in (["config", "show"], ["auth", "status"], ["config", "profiles"]):
-        result = runner.invoke(cli, argv)
-        assert result.exit_code == 0, (argv, result.exception)