@athsra/cli 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athsra/cli",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "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",

package/src/commands/doctor.ts

@@ -5,6 +5,7 @@ import { configFile, loadConfig, sessionFile } from '../lib/config.ts';
 import { partitionEnv } from '../lib/env-format.ts';
 import { readPlain } from '../lib/envelope.ts';
 import { getMasterPw, getToken, probeKeyring } from '../lib/keyring.ts';
+import { summarizeMemberCoverage } from './recipients.ts';
 
 export async function doctorCmd(args: string[]): Promise<number> {
   const audit = args.includes('--audit');
@@ -68,13 +69,28 @@ export async function doctorCmd(args: string[]): Promise<number> {
     console.log(`  info: error — ${(err as Error).message}`);
   }
 
+  let selfUserId: number | undefined;
   if (token) {
     try {
       const me = await client.whoami();
+      selfUserId = me.userId;
       console.log(`  whoami:           machineId=${me.machineId} lastSeenAt=${me.lastSeenAt}`);
     } catch (err) {
       console.log(`  whoami:           ✗ ${(err as Error).message}`);
     }
+    // identity key (server) — 다른 머신·위치의 브라우저 device-login 이 sealed key 를 받는 전제.
+    try {
+      const hasIdentityKey = (await client.getKeys()) !== null;
+      console.log(
+        `  identity key (server): ${
+          hasIdentityKey
+            ? '✓ provisioned (어디서든 device-login 가능)'
+            : '✗ missing — 다른 머신 device-login 불가. `athsra login` 재실행으로 생성.'
+        }`,
+      );
+    } catch (err) {
+      console.log(`  identity key (server): ? ${(err as Error).message}`);
+    }
     try {
       const projects = await client.listProjects();
       const head = projects.slice(0, 5).join(', ');
@@ -82,6 +98,21 @@ export async function doctorCmd(args: string[]): Promise<number> {
       console.log(
         `  projects:         ${projects.length}${projects.length ? ` (${head}${more})` : ''}`,
       );
+      // recipient 커버리지 — 브라우저 로그인(identity) 머신이 master pw 없이 복호 가능한 프로젝트 수.
+      if (selfUserId !== undefined && projects.length > 0) {
+        const uid = selfUserId;
+        const envs = await Promise.all(
+          projects.map((p) => client.getEnvelope(p).catch(() => null)),
+        );
+        const cov = summarizeMemberCoverage(projects, envs, uid);
+        console.log(
+          `  recipient coverage: ${cov.covered}/${cov.total} member-accessible (브라우저 로그인으로 복호)`,
+        );
+        if (cov.gaps.length > 0) {
+          console.log(`    ⚠ master-only (브라우저 로그인 복호 불가): ${cov.gaps.join(', ')}`);
+          console.log('      → 소유자가 `athsra migrate-envelopes --self --apply` 로 보강.');
+        }
+      }
     } catch (err) {
       console.log(`  projects:         fetch error — ${(err as Error).message}`);
     }

package/src/commands/login.ts

@@ -16,7 +16,12 @@ import { readPlain } from '../lib/envelope.ts';
 import { ensureKeypair } from '../lib/identity-key.ts';
 import { probeKeyring, setDeviceToken, setMasterPw, setToken } from '../lib/keyring.ts';
 import { consumeLegacySession } from '../lib/legacy-session.ts';
-import { openBrowser, runOidcPkceFlow, SSO_DEFAULTS } from '../lib/oidc-flow.ts';
+import {
+  openBrowser,
+  resolveOidcEndpoints,
+  runOidcPkceFlow,
+  SSO_DEFAULTS,
+} from '../lib/oidc-flow.ts';
 import { promptConfirm, promptPassword, promptText } from '../lib/prompt.ts';
 
 /**
@@ -25,13 +30,25 @@ import { promptConfirm, promptPassword, promptText } from '../lib/prompt.ts';
  * 실제 공유는 Slice 6. master pw 로 wrap 된 privkey 만 server 보관(평문 미노출).
  */
 async function provisionIdentityKey(client: AthsraClient, masterPw: string): Promise<void> {
-  try {
-    const created = await ensureKeypair(client, masterPw);
-    console.log(created ? '  identity key: provisioned ✓' : '  identity key: present ✓');
-  } catch (err) {
-    console.warn(
-      `  identity key: provisioning deferred (${err instanceof Error ? err.message : String(err)})`,
-    );
+  // identity key = "어디서든 브라우저 device-login" 의 substrate (다른 머신이 sealed key 를 받는 전제).
+  // transient 실패에 1회 재시도, 영구 실패면 silent 가 아니라 결과(다른 머신 device-login 불가)를
+  // 명시 + 멱등 복구 경로 안내. master-pw 사용 자체는 정상이므로 login 을 hard-fail 하진 않는다.
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    try {
+      const created = await ensureKeypair(client, masterPw);
+      console.log(created ? '  identity key: provisioned ✓' : '  identity key: present ✓');
+      return;
+    } catch (err) {
+      if (attempt < 2) continue;
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`  ⚠ identity key 미provisioning (${msg})`);
+      console.warn(
+        '     → 다른 머신·위치에서 브라우저 device-login 이 불가합니다 (이 머신의 master-pw 접근은 정상).',
+      );
+      console.warn(
+        '     → 복구: 네트워크 확인 후 `athsra login` 재실행(멱등). 상태는 `athsra doctor` 로 확인.',
+      );
+    }
   }
 }
 
@@ -81,9 +98,18 @@ async function ssoLoginCmd(): Promise<number> {
   //    env override 해석 후 lib/oidc-flow.ts 에 위임. 실패 시 throw → `✗ ...` + exit 1.
   let accessToken: string;
   try {
+    // endpoint 는 OIDC discovery 로 해석 (하드코딩 /authorize 금지 — connect 는 /sso/* 로 광고).
+    const endpoints = await resolveOidcEndpoints(
+      { discoveryUrl: process.env.ATHSRA_SSO_DISCOVERY_URL ?? SSO_DEFAULTS.discoveryUrl },
+      {
+        authorizeUrl: process.env.ATHSRA_SSO_AUTHORIZE_URL,
+        tokenUrl: process.env.ATHSRA_SSO_TOKEN_URL,
+      },
+    );
+    console.log(`  authorize: ${endpoints.authorizeUrl}`);
     const flow = await runOidcPkceFlow({
-      authorizeUrl: process.env.ATHSRA_SSO_AUTHORIZE_URL ?? SSO_DEFAULTS.authorizeUrl,
-      tokenUrl: process.env.ATHSRA_SSO_TOKEN_URL ?? SSO_DEFAULTS.tokenUrl,
+      authorizeUrl: endpoints.authorizeUrl,
+      tokenUrl: endpoints.tokenUrl,
       clientId: process.env.ATHSRA_SSO_CLIENT_ID ?? SSO_DEFAULTS.clientId,
       scope: SSO_DEFAULTS.scope,
       callbackTimeoutMs: SSO_DEFAULTS.callbackTimeoutMs,
@@ -424,8 +450,9 @@ const LOGIN_USAGE = [
   '  ATHSRA_WORKER_URL           worker URL (config 우선)',
   '  ATHSRA_MASTER_PW            non-interactive master pw',
   '  ATHSRA_PAPER_BACKUP_CONFIRMED=1   paper-backup prompt 우회',
-  '  ATHSRA_SSO_AUTHORIZE_URL    Connect /authorize override',
-  '  ATHSRA_SSO_TOKEN_URL        Connect /token override',
+  '  ATHSRA_SSO_DISCOVERY_URL    OIDC discovery URL (default: login.modfolio.io/.well-known/openid-configuration)',
+  '  ATHSRA_SSO_AUTHORIZE_URL    authorize endpoint override (둘 다 설정 시 discovery 생략)',
+  '  ATHSRA_SSO_TOKEN_URL        token endpoint override (둘 다 설정 시 discovery 생략)',
   '  ATHSRA_SSO_CLIENT_ID        Connect client_id (default: athsra-cli)',
 ].join('\n');
 

package/src/commands/org.ts

@@ -22,7 +22,7 @@ const USAGE = [
   '  athsra org create <name>                   — company org 생성 (owner)',
   '  athsra org ls                              — 내가 멤버인 org 목록 (* = 현재)',
   '  athsra org members                         — 현재 org 멤버',
-  '  athsra org invite <identifier> [--role=member|admin]  — 멤버 초대 (JIT pending)',
+  '  athsra org invite <identifier> [--role=member|admin] [--grant]  — 멤버 초대 (--grant: 공유 즉시 re-wrap)',
   '  athsra org remove <user_id>                — 멤버 제거 (owner 면 DEK 자동 회전)',
   '  athsra org rotate-after-removal <user_id>  — 제거 후 DEK 회전 재개 (부분 실패 복구, owner)',
   '  athsra org grant-access <identifier|id> [--replace]  — 멤버에게 공유 시크릿 re-wrap (--replace=key reset 복구)',
@@ -130,7 +130,7 @@ async function membersCmd(): Promise<number> {
 async function inviteCmd(args: string[]): Promise<number> {
   const identifier = args.filter((a) => !a.startsWith('-'))[0];
   if (!identifier) {
-    console.error('usage: athsra org invite <identifier> [--role=member|admin]');
+    console.error('usage: athsra org invite <identifier> [--role=member|admin] [--grant]');
     return 2;
   }
   let role: 'member' | 'admin' = 'member';
@@ -153,6 +153,28 @@ async function inviteCmd(args: string[]): Promise<number> {
     console.log(
       '  초대받은 사람: athsra login → `athsra org ls` 에 pending 표시 → `athsra org use` 로 수락',
     );
+    // --grant: 초대와 동시에 공유 시크릿 re-wrap(member recipient 추가) — 멤버가 이미 identity 키를
+    // provisioning(로그인)했다면 1-command 으로 접근 부여. 키 부재면 명시 안내(로그인 후 grant-access).
+    if (args.includes('--grant')) {
+      try {
+        const g = await grantOrgAccess(ctx.client, ctx.masterPw, res.user_id, {});
+        if (g.granted.length > 0) {
+          console.log(`✓ 공유 re-wrap — granted ${g.granted.length}: ${g.granted.join(', ')}`);
+        } else {
+          console.log(
+            '  (re-wrap 대상 없음 — 멤버 identity 키 미provisioning 또는 v2 envelope 없음. 멤버 `athsra login` 후 `athsra org grant-access` 재시도)',
+          );
+        }
+        if (g.legacyV1.length > 0) {
+          console.log(`  v1 envelope(먼저 \`athsra migrate-envelopes\`): ${g.legacyV1.join(', ')}`);
+        }
+        for (const f of g.failed) console.error(`  ✗ ${f.project}: ${f.error}`);
+      } catch (err) {
+        console.warn(
+          `  ⚠ 자동 공유 실패 (${(err as Error).message}) — 멤버 \`athsra login\` 후 \`athsra org grant-access ${identifier}\`.`,
+        );
+      }
+    }
     return 0;
   } catch (err) {
     const msg = (err as Error).message;

package/src/commands/recipients.ts

@@ -38,6 +38,29 @@ export async function recipientsCmd(args: string[]): Promise<number> {
   return listRecipientsCmd(args);
 }
 
+/**
+ * member-recipient 커버리지 요약 — browser-login(identity) 머신이 복호 가능한 프로젝트 수.
+ * envelope 에 `member:<userId>` 가 있어야 master pw 없이 복호된다 (`athsra doctor` 가 사용).
+ * 순수 함수 (네트워크 X) — fetch 한 envelope 배열을 받아 집계만 한다.
+ */
+export function summarizeMemberCoverage(
+  projects: string[],
+  envelopes: ({ version: number; recipients?: { id: string }[] } | null)[],
+  userId: number,
+): { covered: number; total: number; gaps: string[] } {
+  const gaps: string[] = [];
+  let covered = 0;
+  projects.forEach((project, i) => {
+    const env = envelopes[i];
+    if (env && env.version === 2 && env.recipients?.some((r) => r.id === `member:${userId}`)) {
+      covered++;
+    } else {
+      gaps.push(project);
+    }
+  });
+  return { covered, total: projects.length, gaps };
+}
+
 async function listRecipientsCmd(args: string[]): Promise<number> {
   if (args.includes('--help') || args.includes('-h')) {
     console.log(USAGE);

package/src/lib/oidc-flow.ts

@@ -13,11 +13,11 @@ import { createHash, randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 
-/** OIDC PKCE 플로우 엔드포인트 + 파라미터 (env override 는 호출부에서 해석해 주입). */
+/** OIDC PKCE 플로우 엔드포인트 + 파라미터 (endpoint 는 discovery 로 해석 후 주입). */
 export interface OidcFlowOptions {
-  /** Connect authorize endpoint */
+  /** Connect authorize endpoint (discovery 로 해석된 값) */
   authorizeUrl: string;
-  /** Connect token endpoint */
+  /** Connect token endpoint (discovery 로 해석된 값) */
   tokenUrl: string;
   /** Connect 측 CLI client (PKCE public, no secret) */
   clientId: string;
@@ -27,15 +27,88 @@ export interface OidcFlowOptions {
   callbackTimeoutMs: number;
 }
 
-export const SSO_DEFAULTS: OidcFlowOptions = {
-  authorizeUrl: 'https://login.modfolio.io/authorize',
-  tokenUrl: 'https://login.modfolio.io/token',
-  /** Connect 측 CLI client (PKCE public, no secret). 사용자가 별도 등록. */
+/**
+ * SSO 기본 설정 — endpoint 는 **discovery 로 해석**하므로 하드코딩하지 않는다.
+ *
+ * connect 는 OIDC 를 `/sso/*` 아래에서만 서빙하고 discovery 문서로 정확히 광고한다.
+ * 과거 bare `/authorize` 하드코딩이 404 의 근본 원인이었다 (connect → athsra 메시지 2026-06-15).
+ */
+export interface SsoConfig {
+  /** OIDC/OAuth discovery 문서 URL (OIDC Discovery / RFC 8414). connect 가 `/sso/*` 를 광고. */
+  discoveryUrl: string;
+  /** 기대 issuer (discovery host 와 분리됨 — RFC 8414). connect 의 issuer 식별자. */
+  issuer: string;
+  /** Connect 측 CLI client (PKCE public, no secret). connect 에 `athsra-cli` 로 등록. */
+  clientId: string;
+  scope: string;
+  callbackTimeoutMs: number;
+}
+
+export const SSO_DEFAULTS: SsoConfig = {
+  discoveryUrl: 'https://login.modfolio.io/.well-known/openid-configuration',
+  issuer: 'https://connect.modfolio.io',
   clientId: 'athsra-cli',
   scope: 'openid profile email',
   callbackTimeoutMs: 5 * 60 * 1000,
 };
 
+/** discovery 로 해석된 endpoint 쌍. */
+export interface ResolvedEndpoints {
+  authorizeUrl: string;
+  tokenUrl: string;
+}
+
+/** OIDC discovery 문서 중 우리가 쓰는 필드만의 타입 가드 (외부 입력 → unknown 검증). */
+function hasOidcEndpoints(
+  v: unknown,
+): v is { authorization_endpoint: string; token_endpoint: string } {
+  if (typeof v !== 'object' || v === null) return false;
+  const o = v as Record<string, unknown>;
+  return typeof o.authorization_endpoint === 'string' && typeof o.token_endpoint === 'string';
+}
+
+/** discovery 실패 시 폴백 — discovery URL 의 origin 에 connect 의 안정 계약(`/sso/*`) 을 붙인다. */
+function fallbackEndpoints(discoveryUrl: string): ResolvedEndpoints {
+  const { origin } = new URL(discoveryUrl);
+  return { authorizeUrl: `${origin}/sso/authorize`, tokenUrl: `${origin}/sso/token` };
+}
+
+/**
+ * authorize/token endpoint 를 OIDC **discovery 로 해석**한다 (정공법 — 하드코딩 경로 금지).
+ *
+ * 우선순위: 명시 override(둘 다 설정 시) > discovery 문서 > 폴백(`/sso/*`).
+ * 어떤 환경(dev/staging/prod)·향후 경로 변경에도 discovery 가 정답을 광고하므로 자동 적응한다.
+ * 부분 override(authorize 또는 token 한쪽)는 그 쪽만 고정하고 나머지는 discovery/폴백에서 채운다.
+ */
+export async function resolveOidcEndpoints(
+  cfg: Pick<SsoConfig, 'discoveryUrl'>,
+  overrides: { authorizeUrl?: string; tokenUrl?: string } = {},
+): Promise<ResolvedEndpoints> {
+  // 명시 override 가 둘 다 있으면 discovery 생략 (오프라인/엣지 E2E).
+  if (overrides.authorizeUrl && overrides.tokenUrl) {
+    return { authorizeUrl: overrides.authorizeUrl, tokenUrl: overrides.tokenUrl };
+  }
+  try {
+    const res = await fetch(cfg.discoveryUrl, { headers: { accept: 'application/json' } });
+    if (res.ok) {
+      const doc: unknown = await res.json();
+      if (hasOidcEndpoints(doc)) {
+        return {
+          authorizeUrl: overrides.authorizeUrl ?? doc.authorization_endpoint,
+          tokenUrl: overrides.tokenUrl ?? doc.token_endpoint,
+        };
+      }
+    }
+  } catch {
+    // 네트워크/파싱 실패 → 폴백 (connect 의 `/sso/*` 는 안정 계약).
+  }
+  const fb = fallbackEndpoints(cfg.discoveryUrl);
+  return {
+    authorizeUrl: overrides.authorizeUrl ?? fb.authorizeUrl,
+    tokenUrl: overrides.tokenUrl ?? fb.tokenUrl,
+  };
+}
+
 interface CallbackResult {
   code: string;
   state: string;