@athsra/cli 1.0.4 → 1.1.0

package/README.md

@@ -21,6 +21,8 @@ curl -fsSL https://bun.sh/install | bash
 
 # CLI 설치
 bun add -g @athsra/cli
+# 또는
+npm i -g @athsra/cli
 ```
 
 > Bun runtime 강제 — TypeScript 직접 실행 + native crypto 성능. Node 호환은 후속 버전.
@@ -39,16 +41,16 @@ cd ~/code/athsra && bun install
 bash scripts/setup-worker.sh    # R2 + KV + GLOBAL_SALT + deploy 멱등
 ```
 
-### 2. 첫 머신 등록 (PROOF bootstrap)
+### 2. 로그인
 
 ```bash
-# (권장) BIP-39 12-word recovery phrase 생성
-athsra new-phrase   # 12 단어 출력 → 종이에 정확히 적기
+# 일반 머신/AI agent: 브라우저 device flow.
+ATHSRA_WORKER_URL=https://athsra-worker.<account>.workers.dev athsra login
+# URL + 코드 + 디바이스 지문 출력 → 브라우저에서 승인
 
-athsra login
-# Worker URL: https://athsra-worker.<account>.workers.dev
-# Master password: <위 phrase 또는 자유 phrase>
-# Paper backup confirm: yes
+# founding owner / 복구용 full-access 머신:
+athsra new-phrase   # 12 단어 출력 → 종이에 정확히 적기
+ATHSRA_WORKER_URL=https://athsra-worker.<account>.workers.dev athsra login --password
 ```
 
 ### 3. 평소 사용
@@ -99,11 +101,32 @@ ATHSRA_MASTER_PW='<기존과 동일>' \
   athsra handoff --accept
 ```
 
+## MCP — AI agent 표면 (Claude Code / Cursor / VS Code)
+
+npm 에서 이 패키지를 발견한 AI 에이전트라면: athsra 는 **MCP 로 전 기능을 자율 조작**하도록 설계됐다 — 평문 시크릿 값은 단 한 번도 에이전트에게 노출되지 않는다.
+
+```sh
+athsra mcp install --write --apply      # .mcp.json 등록 (dry-run 기본 — --apply 가 실제 변경)
+# --client cursor|vscode  --scope user  --admin  지원
+```
+
+1. **인증은 채팅 안에서** — `athsra_whoami` → 미인증이면 `athsra_login_start` 호출 (터미널 불필요). 반환된 URL+코드+디바이스 지문을 사용자에게 전달 → 사용자가 브라우저에서 가입/로그인 + master password 로 승인 (**master pw 는 브라우저 밖으로 안 나감**) → `athsra_login_status` poll (retry_after 준수) → approved.
+2. **3-tier 도구 27종**:
+   - read 12 (항상): `whoami` · `login_start/status` · `list_projects` · `get_project_keys`(키 이름만) · `versions` · `audit` · `list_orgs` · `org_info` · `doctor` · `show/validate_manifest`
+   - write 8 (`ATHSRA_MCP_WRITE=1`): `set_secret` · `unset_secret` · `bulk_set` · `rollback` · `delete_project`(soft) · `restore_project` · `manifest_init/modify`
+   - admin 7 (`ATHSRA_MCP_ADMIN=1`): `org_invite` · `org_remove_member` · `project_share/unshare` · `service_token_create/revoke` · `purge` — destructive 는 `confirm` 정확일치 필수
+3. **값 무노출 원칙**: 값 소비는 MCP 밖 `athsra run <p> -- <cmd>` 주입으로만. `athsra get`/`run` 은 의도적으로 MCP 도구가 아니다. 유일 예외 = `athsra_service_token_create` 의 1회성 `ats_*` 반환 (즉시 secret store 보관).
+
+전체 가이드: [athsra.com/ai](https://athsra.com/ai) · [athsra.com/llms.txt](https://athsra.com/llms.txt)
+
 ## 전체 명령
 
 | 명령 | 동작 |
 |---|---|
-| `athsra login` | 첫 등록 (PROOF bootstrap) |
+| `athsra login` | 브라우저 완결 identity 로그인 기본 (`--password` = founding master pw 등록, `--sso`, `--device`) |
+| `athsra mcp` | MCP stdio server (AI agent 표면 — 위 섹션) |
+| `athsra mcp install` | MCP client 설정 등록/갱신 (claude/cursor/vscode, dry-run 기본) |
+| `athsra service-token create/list/revoke` | scoped headless 토큰 (NAS/CI — master pw 없이 복호) |
 | `athsra set <p> KEY=val [...]` | secret 추가/수정 (`--from-file` / `--stdin` 지원) |
 | `athsra unset <p> KEY [...]` | 특정 key 제거 (envelope 유지) |
 | `athsra get <p> [KEY]` | 값 출력 (single 또는 dump) |
@@ -126,7 +149,7 @@ ATHSRA_MASTER_PW='<기존과 동일>' \
 | 위협 | 완화 |
 |---|---|
 | R2 leak (CF 침해) | E2EE — ciphertext 만 노출. Argon2id m=64MB × t=3 brute-force 비용 |
-| token leak (머신 도난) | `athsra revoke` (KV ~60s eventual). master pw 모름 → decrypt 불가 |
+| token leak (머신 도난) | `athsra revoke` (D1 strong consistency). master pw 또는 identity key 없으면 decrypt 불가 |
 | handoff token 가로챔 | TTL 1h + single-use settle (Phase 1.2) |
 | master pw leak | `rotate-master` — 모든 PROOF/token 갱신 + 모든 envelope re-encrypt |
 | **master pw 분실** | **종이 backup 필수** + BIP-39 12-word phrase. recovery 없음 (E2EE 본질) |
@@ -150,6 +173,7 @@ Server (athsra-worker, BSL 1.1) 는 별도 license — see [main repo](https://g
 
 ## Status
 
-**Phase 1.x.1 active** (2026-05-04+) — soft-delete + version history. universe internal alpha.
+**Phase 5 RC** (2026-06-12) — identity device-login + MCP 27 tools + envelope member/self
+recipients. Published package target: `@athsra/cli@1.1.0`.
 
 [ROADMAP.md](https://github.com/modfolio/athsra/blob/main/docs/ROADMAP.md) — 남은 작업 + 미래 분기점 SSoT.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athsra/cli",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "athsra CLI — E2EE secret manager on Cloudflare edge. Doppler-style dev UX + zero-knowledge encryption + soft-delete + version history. MIT.",
   "type": "module",
   "main": "./src/index.ts",
@@ -43,9 +43,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@athsra/crypto": "^1.0.1",
+    "@athsra/crypto": "^1.1.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@napi-rs/keyring": "^1.1.6",
+    "@napi-rs/keyring": "^1.3.0",
     "prompts": "^2.4.2"
   },
   "devDependencies": {

package/src/commands/delete.ts

@@ -1,26 +1,29 @@
 import { loadAuthContext } from '../lib/auth-context.ts';
+import { CONFIG_USAGE_HINT, configTag, projectRef, resolveProject } from '../lib/auto-project.ts';
 import { promptConfirm } from '../lib/prompt.ts';
 
 const USAGE = [
-  'usage: athsra delete <project>           # soft-delete (versions 보존, restore 가능)',
-  '   or: athsra delete <project> --hard    # hard-delete (모든 versions 영구 제거)',
-  '   or: athsra delete <project> --yes     # confirm 우회 (CI 용)',
+  'usage: athsra delete <project>[:<env>]           # soft-delete (versions 보존, restore 가능)',
+  '   or: athsra delete <project>[:<env>] --hard    # hard-delete (모든 versions 영구 제거)',
+  '   or: athsra delete <project>[:<env>] --yes     # confirm 우회 (CI 용)',
+  CONFIG_USAGE_HINT,
 ].join('\n');
 
 /**
- * athsra delete <project>
- *   - soft (default): tombstone marker 작성, versions 보존, restore 가능
+ * athsra delete <project>[:<env>]
+ *   - soft (default): tombstone marker 작성, versions 보존, restore 가능 (해당 환경(config) 한정)
  *   - --hard: 모든 versions + tombstone 영구 제거. 복원 불가능.
  *   - confirm 필요 (--yes 또는 ATHSRA_DELETE_CONFIRMED=1 로 우회)
  */
 export async function deleteCmd(args: string[]): Promise<number> {
-  const project = args[0];
+  const { project, config, rest } = resolveProject(args, { requirePositional: true });
   if (!project) {
     console.error(USAGE);
     return 2;
   }
-  const hard = args.includes('--hard');
-  const yes = args.includes('--yes') || args.includes('-y');
+  const hard = rest.includes('--hard');
+  const yes = rest.includes('--yes') || rest.includes('-y');
+  const tag = configTag(config);
 
   const ctx = await loadAuthContext();
   if (!ctx) return 1;
@@ -28,20 +31,20 @@ export async function deleteCmd(args: string[]): Promise<number> {
 
   if (!yes && process.env.ATHSRA_DELETE_CONFIRMED !== '1') {
     const msg = hard
-      ? `HARD-DELETE ${project}? All version history permanently removed. NOT RECOVERABLE.`
-      : `Soft-delete ${project}? Restore via 'athsra restore ${project}'.`;
+      ? `HARD-DELETE ${project}${tag}? All version history permanently removed. NOT RECOVERABLE.`
+      : `Soft-delete ${project}${tag}? Restore via 'athsra restore ${projectRef(project, config)}'.`;
     const ok = await promptConfirm(msg, false);
     if (!ok) return 0;
   }
 
-  const result = await client.deleteProject(project, { hard });
+  const result = await client.deleteProject(project, { hard, config });
   if (hard) {
     console.log(
-      `✓ ${project}: hard-deleted (${result.removed_versions ?? 0} version${(result.removed_versions ?? 0) === 1 ? '' : 's'} removed)`,
+      `✓ ${project}${tag}: hard-deleted (${result.removed_versions ?? 0} version${(result.removed_versions ?? 0) === 1 ? '' : 's'} removed)`,
     );
   } else {
     console.log(
-      `✓ ${project}: soft-deleted (${result.recoverable_versions ?? 0} version${(result.recoverable_versions ?? 0) === 1 ? '' : 's'} recoverable via 'athsra restore')`,
+      `✓ ${project}${tag}: soft-deleted (${result.recoverable_versions ?? 0} version${(result.recoverable_versions ?? 0) === 1 ? '' : 's'} recoverable via 'athsra restore')`,
     );
   }
   return 0;

package/src/commands/get.ts

@@ -1,21 +1,24 @@
 import { loadAuthContext } from '../lib/auth-context.ts';
+import { CONFIG_USAGE_HINT, configTag, resolveProject } from '../lib/auto-project.ts';
 import { serializeEnv } from '../lib/env-format.ts';
 import { readPlain } from '../lib/envelope.ts';
 
+const USAGE = ['usage: athsra get <project>[:<env>] [KEY]', CONFIG_USAGE_HINT].join('\n');
+
 export async function getCmd(args: string[]): Promise<number> {
-  const project = args[0];
-  const key = args[1];
+  const { project, config, rest } = resolveProject(args, { requirePositional: true });
+  const key = rest[0];
   if (!project) {
-    console.error('usage: athsra get <project> [KEY]');
+    console.error(USAGE);
     return 2;
   }
 
   const ctx = await loadAuthContext();
   if (!ctx) return 1;
 
-  const plain = await readPlain(ctx, project);
+  const plain = await readPlain(ctx, project, config);
   if (!plain) {
-    console.error(`project not found: ${project}`);
+    console.error(`project not found: ${project}${configTag(config)}`);
     return 1;
   }
 

package/src/commands/handoff.ts

@@ -1,6 +1,6 @@
 import { hostname } from 'node:os';
-import { deriveKey, fromBase64, toBase64 } from '@athsra/crypto';
 import { loadAuthContext, type UserAuthContext } from '../lib/auth-context.ts';
+import { deriveMasterProof } from '../lib/auth-proof.ts';
 import { AthsraClient } from '../lib/client.ts';
 import { type Config, saveConfig } from '../lib/config.ts';
 import { readPlain } from '../lib/envelope.ts';
@@ -29,7 +29,12 @@ async function issueToken(): Promise<number> {
   }
 
   const info = await client.info();
-  const proof = toBase64(deriveKey(masterPw, fromBase64(info.global_salt)));
+  const me = await client.whoami();
+  if (me.userId === undefined) {
+    console.error('whoami 에 user_id 없음 — 재로그인 필요 (`athsra login`).');
+    return 1;
+  }
+  const proof = deriveMasterProof(masterPw, me.userId, info.global_salt);
   const result = await client.handoff(proof, newLabel);
 
   const ttlMin = result.ttlSeconds ? Math.floor(result.ttlSeconds / 60) : null;
@@ -93,6 +98,10 @@ async function acceptToken(): Promise<number> {
     console.error(`✗ token invalid: ${(err as Error).message}`);
     return 1;
   }
+  if (me.userId === undefined) {
+    console.error('✗ token 에 user_id 없음 — 재로그인 필요 (`athsra login`).');
+    return 1;
+  }
 
   // master pw 검증: 첫 envelope (있으면) decrypt 시도 (v1/v2 dispatcher)
   const projects = await client.listProjects();
@@ -100,7 +109,7 @@ async function acceptToken(): Promise<number> {
   if (first) {
     const tempCtx: UserAuthContext = {
       kind: 'user',
-      config: { workerUrl, machineId, createdAt: me.createdAt },
+      config: { workerUrl, machineId, createdAt: me.createdAt, userId: me.userId },
       masterPw,
       token,
       client,
@@ -118,6 +127,7 @@ async function acceptToken(): Promise<number> {
     workerUrl,
     machineId,
     createdAt: me.createdAt,
+    userId: me.userId,
   };
   saveConfig(config);
   setMasterPw(machineId, masterPw);

package/src/commands/login.ts

@@ -1,15 +1,16 @@
 import { hostname } from 'node:os';
-import {
-  deriveProof,
-  fromBase64,
-  isValidPhrase,
-  normalizePhrase,
-  toBase64,
-  wordCount,
-} from '@athsra/crypto';
+import { isValidPhrase, normalizePhrase, wordCount } from '@athsra/crypto';
+import { deriveMasterProof } from '../lib/auth-proof.ts';
 import { resolveProject } from '../lib/auto-project.ts';
 import { AthsraClient } from '../lib/client.ts';
 import { type Config, loadConfig, saveConfig } from '../lib/config.ts';
+import {
+  completeIdentityLogin,
+  DEFAULT_WORKER_URL,
+  type IdentityFlow,
+  runDevicePollLoop,
+  startIdentityFlow,
+} from '../lib/device-login.ts';
 import { ensureKeypair } from '../lib/identity-key.ts';
 import { probeKeyring, setDeviceToken, setMasterPw, setToken } from '../lib/keyring.ts';
 import { consumeLegacySession } from '../lib/legacy-session.ts';
@@ -133,12 +134,16 @@ async function ssoLoginCmd(): Promise<number> {
   //   proof = Argon2id(masterPw, perUserSalt(user_id, GLOBAL_SALT)) 단방향 해시 — 평문 송신 X (E2EE).
   //   G-1: per-user salt 로 같은 pw 두 user 도 proof 가 유일. 첫 SSO = bootstrap, 재로그인 = 검증.
   const info = await tempClient.info();
-  const proof = toBase64(deriveProof(masterPw, ssoBody.user_id, fromBase64(info.global_salt)));
+  const proof = deriveMasterProof(masterPw, ssoBody.user_id, info.global_salt);
   try {
     const pr = await new AthsraClient(workerUrl, ssoBody.token).setProof(
       proof,
       info.global_salt_version,
     );
+    if (pr.userId !== ssoBody.user_id) {
+      console.error(`✗ proof user mismatch (${pr.userId} ≠ ${ssoBody.user_id}) — 재로그인 필요.`);
+      return 1;
+    }
     if (pr.version_reset) {
       console.log('• Master password re-registered (GLOBAL_SALT changed).');
     } else if (pr.bootstrap) {
@@ -162,6 +167,7 @@ async function ssoLoginCmd(): Promise<number> {
     workerUrl,
     machineId,
     createdAt: existing?.createdAt ?? ssoBody.createdAt,
+    userId: ssoBody.user_id,
   };
   saveConfig(config);
   setMasterPw(machineId, masterPw);
@@ -178,9 +184,6 @@ async function ssoLoginCmd(): Promise<number> {
   return 0;
 }
 
-/** 비-인터랙티브 agent 기본 worker (config/env 없을 때). production athsra worker. */
-const DEFAULT_WORKER_URL = 'https://athsra-worker.winterermod.workers.dev';
-
 interface DeviceArgs {
   project?: string;
   perms: 'read' | 'write';
@@ -216,8 +219,6 @@ function parseDeviceArgs(args: string[]): DeviceArgs {
   return { project, perms, noBrowser };
 }
 
-const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
-
 /**
  * Phase 3 P3 (2026-05-31) — device-login (RFC 8628 적응).
  *
@@ -268,56 +269,143 @@ async function deviceLoginCmd(args: string[]): Promise<number> {
   console.log('  (master pw 는 그 브라우저에서 1회 — 이 기기엔 저장되지 않습니다)\n');
   if (!noBrowser) openBrowser(dc.verification_uri_complete);
 
-  // poll
-  let interval = Math.max(1, dc.interval) * 1000;
-  const deadline = Date.now() + dc.expires_in * 1000;
+  // poll (lib/device-login.ts 공용 루프 — Phase 5 B5 추출)
   process.stdout.write('  대기 중');
-  while (Date.now() < deadline) {
-    await sleep(interval);
-    let result: Awaited<ReturnType<typeof client.devicePollToken>>;
-    try {
-      result = await client.devicePollToken(dc.device_code);
-    } catch {
-      process.stdout.write('.');
-      continue;
-    }
-    if (result.status === 'token') {
-      setDeviceToken(project, result.token);
-      saveConfig({
-        workerUrl,
-        machineId,
-        createdAt: existing?.createdAt ?? new Date().toISOString(),
-      });
-      console.log('\n\n✓ device-login 완료');
-      console.log(`  project: ${result.project} (${result.perms})`);
-      console.log('  keyring: device token 저장 (master pw 불필요)');
-      console.log(`  사용:    athsra run ${result.project} -- <command>\n`);
-      return 0;
-    }
-    // pending / terminal
-    if (result.error === 'access_denied') {
-      console.error('\n\n✗ 승인이 거부되었습니다.');
-      return 1;
-    }
-    if (result.error === 'expired_token') {
-      console.error('\n\n✗ 요청이 만료되었습니다. `athsra login --device` 재시도.');
-      return 1;
-    }
-    if (result.error === 'slow_down') {
-      interval += 5000;
+  const outcome = await runDevicePollLoop(client, dc.device_code, {
+    intervalMs: Math.max(1, dc.interval) * 1000,
+    expiresAt: Date.now() + dc.expires_in * 1000,
+    onTick: () => process.stdout.write('.'),
+  });
+  if (outcome.step === 'denied') {
+    console.error('\n\n✗ 승인이 거부되었습니다.');
+    return 1;
+  }
+  if (outcome.step === 'expired') {
+    console.error('\n\n✗ 요청이 만료되었습니다. `athsra login --device` 재시도.');
+    return 1;
+  }
+  if (outcome.step === 'timeout') {
+    console.error('\n\n✗ 승인 대기 시간 초과. `athsra login --device` 재시도.');
+    return 1;
+  }
+  const result = outcome.result;
+  if (result.tokenType !== 'service') {
+    console.error('\n\n✗ 예상치 못한 user-kind 토큰 (service device-login).');
+    return 1;
+  }
+  setDeviceToken(project, result.token);
+  saveConfig({
+    workerUrl,
+    machineId,
+    createdAt: existing?.createdAt ?? new Date().toISOString(),
+  });
+  console.log('\n\n✓ device-login 완료');
+  console.log(`  project: ${result.project} (${result.perms})`);
+  console.log('  keyring: device token 저장 (master pw 불필요)');
+  console.log(`  사용:    athsra run ${result.project} -- <command>\n`);
+  return 0;
+}
+
+/** identity login 후 best-effort 검증 — whoami (실패해도 login 성공 유지). */
+async function verifyIdentityLogin(client: AthsraClient): Promise<void> {
+  try {
+    const me = await client.whoami();
+    if (me.userId !== undefined) {
+      console.log(`  verified:   user #${me.userId} ✓`);
     }
-    process.stdout.write('.');
+  } catch {
+    console.warn('  verify:     보류 (login 자체는 성공 — 다음 명령에서 재확인).');
   }
-  console.error('\n\n✗ 승인 대기 시간 초과. `athsra login --device` 재시도.');
-  return 1;
+}
+
+/**
+ * Phase 5 (2026-06-12) — identity device-login (기본 `athsra login`).
+ *
+ * 브라우저 완결 흐름 (TTY 0회, master pw 이 머신 미보관):
+ *   1. 디바이스 X25519 키쌍 생성 (privkey 는 이 머신에만 — sealed-box unseal 용)
+ *   2. deviceCode(kind:user, device_pub_key) → user_code + URL + fingerprint 출력 + openBrowser
+ *   3. 사용자가 athsra.com/device 에서 로그인 + master pw 로 identity priv 봉인 → complete
+ *   4. poll → {token(atk_*), sealed_identity_key, user_id, key_version}
+ *   5. unseal(user_id 대조) → identity priv → keyring 저장 + token + config.userId
+ *   6. whoami best-effort 검증
+ */
+async function identityLoginCmd(args: string[]): Promise<number> {
+  const noBrowser = args.includes('--no-browser');
+
+  // 1. flow 시작 (keyring probe → config/worker 해석 → 키쌍 생성 → deviceCode) —
+  //    lib/device-login.ts 공용 코어 (Phase 5 B5 추출, MCP athsra_login_start 와 동일 경로).
+  let flow: IdentityFlow;
+  try {
+    flow = await startIdentityFlow();
+  } catch (err) {
+    console.error(`✗ ${(err as Error).message}`);
+    return 1;
+  }
+
+  console.log('\n● athsra login — 브라우저에서 승인이 필요합니다\n');
+  console.log(`  1. 열기:    ${flow.verificationUriComplete}`);
+  console.log(`  2. 코드:    ${flow.userCode}`);
+  console.log(
+    `  3. 지문:    ${flow.fingerprint}   ← 브라우저 화면의 지문과 일치하는지 확인 (phishing 가드)`,
+  );
+  console.log('\n  athsra.com 에 로그인 후 master password 로 승인하면 자동 진행됩니다.');
+  console.log('  (master password 는 그 브라우저에서만 — 이 기기엔 저장되지 않습니다)\n');
+  if (!noBrowser) openBrowser(flow.verificationUriComplete);
+
+  // 2. poll (공용 루프)
+  process.stdout.write('  대기 중');
+  const outcome = await runDevicePollLoop(flow.client, flow.deviceCode, {
+    intervalMs: flow.intervalMs,
+    expiresAt: flow.expiresAt,
+    onTick: () => process.stdout.write('.'),
+  });
+  if (outcome.step === 'denied') {
+    console.error('\n\n✗ 승인이 거부되었습니다.');
+    return 1;
+  }
+  if (outcome.step === 'expired') {
+    console.error('\n\n✗ 요청이 만료되었습니다. `athsra login` 재시도.');
+    return 1;
+  }
+  if (outcome.step === 'timeout') {
+    console.error('\n\n✗ 승인 대기 시간 초과. `athsra login` 재시도.');
+    return 1;
+  }
+  const result = outcome.result;
+  if (result.tokenType !== 'user') {
+    console.error('\n\n✗ 예상치 못한 service 토큰 (identity login).');
+    return 1;
+  }
+
+  // 3. unseal(user_id 대조) → keyring identity+token → config.userId (공용 완료 처리)
+  try {
+    await completeIdentityLogin({
+      result,
+      devicePrivateKey: flow.devicePrivateKey,
+      machineId: flow.machineId,
+      workerUrl: flow.workerUrl,
+      existingCreatedAt: flow.existingCreatedAt,
+    });
+  } catch (err) {
+    console.error(`\n\n✗ identity key unseal 실패: ${(err as Error).message}`);
+    return 1;
+  }
+  console.log('\n\n✓ logged in (identity 모드)');
+  console.log(`  machine:    ${flow.machineId}`);
+  console.log(`  worker:     ${flow.workerUrl}`);
+  console.log('  keyring:    identity key + token 저장 (master pw 이 기기엔 없음)');
+  // 4. best-effort 검증
+  await verifyIdentityLogin(new AthsraClient(flow.workerUrl, result.token));
+  return 0;
 }
 
 const LOGIN_USAGE = [
-  'usage: athsra login [--sso | --device]',
+  'usage: athsra login [--password | --sso | --device]',
   '',
-  '기본 (master pw + paper backup): athsra login',
+  '기본 (identity device-login, master pw 이 기기 미보관): athsra login',
+  'master pw register (founding owner, full 권한): athsra login --password',
   'SSO (modfolio-connect OIDC PKCE — Phase 2.8): athsra login --sso',
-  'device (비-TTY agent, master pw 불필요 — Phase 3 P3): athsra login --device [--project <p>] [--write]',
+  'device (비-TTY agent, project-scoped — Phase 3 P3): athsra login --device [--project <p>] [--write]',
   '',
   'device-login: agent 가 user_code 출력 → 사용자가 athsra.com/device 에서 1-click 승인 →',
   '  project-scoped ats_* 수령 (keyring 저장). master pw 는 승인 브라우저에서만 사용.',
@@ -342,7 +430,18 @@ export async function loginCmd(args: string[]): Promise<number> {
   if (args.includes('--sso')) {
     return ssoLoginCmd();
   }
-  console.log('athsra login\n');
+  if (args.includes('--password')) {
+    return passwordLoginCmd();
+  }
+  return identityLoginCmd(args);
+}
+
+/**
+ * 기존 기본 — founding(user 1) master pw register. Phase 5 부터 `--password` 로 명시.
+ * identity 모드(신규 기본)와 달리 이 머신 keyring 에 master pw 보관 (full owner 권한).
+ */
+async function passwordLoginCmd(): Promise<number> {
+  console.log('athsra login --password\n');
 
   // 1. keyring backend probe (정공법: fallback 없음)
   const probe = probeKeyring();
@@ -451,13 +550,18 @@ export async function loginCmd(args: string[]): Promise<number> {
   // password register 는 founding singleton(user 1) 전용(SSO 외 유일 경로) — userId=1 고정.
   // 다중 사용자 self-serve password register 는 out-of-scope(SSO-gated 유지).
   const FOUNDING_USER_ID = 1;
-  const proofBytes = deriveProof(masterPw, FOUNDING_USER_ID, fromBase64(info.global_salt));
-  const proofBase64 = toBase64(proofBytes);
+  const proofBase64 = deriveMasterProof(masterPw, FOUNDING_USER_ID, info.global_salt);
 
   // 8. register → token
   let reg: Awaited<ReturnType<typeof tempClient.register>>;
   try {
     reg = await tempClient.register(proofBase64, machineId);
+    if (reg.userId !== undefined && reg.userId !== FOUNDING_USER_ID) {
+      console.error(
+        `✗ register user mismatch (${reg.userId} ≠ ${FOUNDING_USER_ID}) — worker 확인 필요.`,
+      );
+      return 1;
+    }
   } catch (err) {
     const msg = (err as Error).message;
     if (msg.includes('401')) {
@@ -474,6 +578,7 @@ export async function loginCmd(args: string[]): Promise<number> {
     workerUrl,
     machineId,
     createdAt: existing?.createdAt ?? reg.createdAt,
+    userId: reg.userId ?? FOUNDING_USER_ID,
   };
   saveConfig(config);
   setMasterPw(machineId, masterPw);

package/src/commands/logout.ts

@@ -2,7 +2,7 @@ import { existsSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { loadConfig } from '../lib/config.ts';
-import { clearMasterPw, clearToken } from '../lib/keyring.ts';
+import { clearIdentityKey, clearMasterPw, clearToken } from '../lib/keyring.ts';
 import { promptConfirm } from '../lib/prompt.ts';
 
 /**
@@ -33,8 +33,9 @@ export async function logoutCmd(args: string[]): Promise<number> {
 
   clearMasterPw(config.machineId);
   clearToken(config.machineId);
+  clearIdentityKey(config.machineId);
   console.log(`✓ keyring cleared for machine: ${config.machineId}`);
-  console.log('  • master-pw + Bearer token removed from OS keyring');
+  console.log('  • master-pw + identity key + Bearer token removed from OS keyring');
   console.log('  • worker-side token still active — `athsra revoke` to invalidate fully');
 
   if (full) {

package/src/commands/ls.ts

@@ -1,23 +1,30 @@
 import { loadAuthContext } from '../lib/auth-context.ts';
+import { configTag, projectRef, resolveProject } from '../lib/auto-project.ts';
 import { partitionEnv } from '../lib/env-format.ts';
 import { readPlain } from '../lib/envelope.ts';
 
+/** ls 자체 flag — project/config 해석 전에 args 에서 제거 (positional 오인 방지). */
+const LS_FLAGS = ['--all', '--include-deleted', '--configs'];
+
 /**
  * athsra ls                       — active projects only
  * athsra ls --all                 — active + soft-deleted (deleted 표시)
  * athsra ls --include-deleted     — alias of --all
- * athsra ls <project>             — keys of project (decrypt 필요)
+ * athsra ls <project>[:<env>]     — keys of a project/environment (decrypt 필요)
+ * athsra ls <project> --configs   — environments(config) of a project + active/deleted 상태
  */
 export async function lsCmd(args: string[]): Promise<number> {
   const ctx = await loadAuthContext();
   if (!ctx) return 1;
   const client = ctx.client;
 
-  const positional = args.filter((a) => !a.startsWith('-'));
+  const wantConfigs = args.includes('--configs');
   const includeDeleted = args.includes('--all') || args.includes('--include-deleted');
+  const cleaned = args.filter((a) => !LS_FLAGS.includes(a));
+  const { project, config } = resolveProject(cleaned, { requirePositional: true });
 
   // ls — project 목록
-  if (positional.length === 0) {
+  if (!project) {
     const result = await client.listProjectsExtended({ includeDeleted });
     if (result.count === 0) {
       console.log('(no projects yet — run `athsra set <project> KEY=value`)');
@@ -37,30 +44,45 @@ export async function lsCmd(args: string[]): Promise<number> {
     return 0;
   }
 
-  // ls <project> — key 목록 + 값 상태 ((empty) 또는 길이, decrypt 필요)
-  const project = positional[0];
-  if (!project) return 0;
+  // ls <project> --configs — 환경(config) 목록 + 각 active/deleted 상태 (default 는 * 표시)
+  if (wantConfigs) {
+    const result = await client.listConfigs(project);
+    if (result.count === 0) {
+      console.log(`(no environments for ${project})`);
+      return 0;
+    }
+    const width = Math.max(...result.configs.map((cfg) => cfg.config.length));
+    for (const cfg of result.configs) {
+      const status = cfg.deleted ? '(deleted)' : cfg.active ? 'active' : '(empty)';
+      const star = cfg.config === 'default' ? '*' : ' ';
+      console.log(`${star} ${cfg.config.padEnd(width)}  ${status}`);
+    }
+    console.log(`(${result.count} environment${result.count > 1 ? 's' : ''})`);
+    return 0;
+  }
 
-  const plain = await readPlain(ctx, project);
+  // ls <project>[:<env>] — key 목록 + 값 상태 ((empty) 또는 길이, decrypt 필요)
+  const plain = await readPlain(ctx, project, config);
   if (!plain) {
-    console.error(`project not found: ${project}`);
+    console.error(`project not found: ${project}${configTag(config)}`);
     return 1;
   }
   const keys = Object.keys(plain).sort();
   if (keys.length === 0) {
-    console.log('(no keys)');
+    console.log(`(no keys${configTag(config)})`);
     return 0;
   }
   const { filled, emptyKeys } = partitionEnv(plain);
   const emptySet = new Set(emptyKeys);
   const width = Math.max(...keys.map((k) => k.length));
+  if (config !== 'default') console.log(`# config: ${config}`);
   for (const k of keys) {
     const status = emptySet.has(k) ? '(empty)' : `${(filled[k] ?? '').length} chars`;
     console.log(`${k.padEnd(width)}  ${status}`);
   }
   if (emptyKeys.length > 0) {
     console.error(
-      `\n${emptyKeys.length} of ${keys.length} key${keys.length > 1 ? 's' : ''} empty — \`athsra run\` skips empty keys (parent env used). Set values: \`athsra set ${project} KEY=value\``,
+      `\n${emptyKeys.length} of ${keys.length} key${keys.length > 1 ? 's' : ''} empty — \`athsra run\` skips empty keys (parent env used). Set values: \`athsra set ${projectRef(project, config)} KEY=value\``,
     );
   }
   return 0;