@athsra/cli 1.0.4 → 1.1.1

package/src/lib/envelope.ts

@@ -22,6 +22,9 @@ import {
   type SecretEnvelopeV2,
 } from '@athsra/crypto';
 import {
+  addMemberRecipient,
+  createEnvelopeAsMember,
+  createEnvelopeWithSelf,
   decryptEnvelopeAsMember,
   reEncryptAsMember,
   unwrapPrivateKey,
@@ -62,7 +65,54 @@ async function memberRecipientUserId(
   return env.recipients.some((r) => r.id === `member:${me.userId}`) ? me.userId : null;
 }
 
+/**
+ * Phase 5 — master(owner) write 의 member:self 재료 (whoami + getKeys). best-effort: 키 미
+ * provisioning/오프라인이면 null → master-only 폴백(기존 동작 보존, migrate --self 가 다음 기회).
+ */
+async function selfMember(
+  ctx: UserAuthContext,
+): Promise<{ publicKey: Uint8Array; userId: number } | null> {
+  try {
+    const me = await ctx.client.whoami();
+    if (me.userId === undefined) return null;
+    const keyRow = await ctx.client.getKeys();
+    if (!keyRow) return null;
+    return { publicKey: fromBase64(keyRow.public_key), userId: me.userId };
+  } catch {
+    return null;
+  }
+}
+
+/** routine master write 시 member:self 부재면 1회 추가. 403/실패면 env 그대로(body-only 폴백). */
+async function ensureSelfRecipient(
+  ctx: UserAuthContext,
+  env: SecretEnvelopeV2,
+  self: { publicKey: Uint8Array; userId: number } | null,
+): Promise<SecretEnvelopeV2> {
+  if (!self) return env;
+  if (env.recipients.some((r) => r.id === `member:${self.userId}`)) return env;
+  try {
+    return await addMemberRecipient(env, ctx.masterPw, self.publicKey, self.userId);
+  } catch {
+    return env;
+  }
+}
+
 async function decryptEnvelope(env: SecretEnvelopeAny, ctx: AuthContext): Promise<string> {
+  // Phase 5 — identity 모드: master pw 없이 내 X25519 키로 멤버 경로 복호 (member:me recipient).
+  if (ctx.kind === 'identity') {
+    if (env.version !== 2) {
+      throw new Error(
+        'identity 로그인은 envelope v2 만 복호 가능 — master pw 머신에서 `athsra set` 1회로 v1→v2 마이그레이션 필요.',
+      );
+    }
+    if (!env.recipients.some((r) => r.id === `member:${ctx.userId}`)) {
+      throw new Error(
+        '이 시크릿에 내 멤버 recipient 가 없습니다 — master pw 머신에서 `athsra migrate-envelopes --self` 1회 실행 후 재시도.',
+      );
+    }
+    return decryptEnvelopeAsMember(env, ctx.identityPrivateKey, ctx.userId);
+  }
   if (ctx.kind === 'user') {
     if (env.version === 2) {
       try {
@@ -100,8 +150,9 @@ async function decryptEnvelope(env: SecretEnvelopeAny, ctx: AuthContext): Promis
 export async function readPlain(
   ctx: AuthContext,
   project: string,
+  config = 'default',
 ): Promise<Record<string, string> | null> {
-  const env = await ctx.client.getEnvelope(project);
+  const env = await ctx.client.getEnvelope(project, config);
   if (!env) return null;
   const text = await decryptEnvelope(env, ctx);
   return parseEnv(text);
@@ -116,30 +167,67 @@ export async function writePlain(
   ctx: AuthContext,
   project: string,
   plain: Record<string, string>,
-  opts?: { kdfParams?: KDFParams },
+  opts?: { kdfParams?: KDFParams; config?: string },
 ): Promise<SecretEnvelopeV2> {
-  if (ctx.kind !== 'user') {
+  if (ctx.kind === 'service') {
     throw new Error('service token cannot write envelopes — use a user token (master pw)');
   }
+  const config = opts?.config ?? 'default';
   const serialized = serializeEnv(plain);
 
+  // Phase 5 — identity 모드: master pw 없이 멤버 경로로 본문 재암호(recipients 보존)/신규 생성.
+  if (ctx.kind === 'identity') {
+    if (opts?.kdfParams) {
+      throw new Error('rotate-master 는 master pw 가 필요합니다 (identity 로그인 머신에선 불가).');
+    }
+    const existing = await ctx.client.getEnvelope(project, config);
+    if (existing && existing.version === 2) {
+      if (!existing.recipients.some((r) => r.id === `member:${ctx.userId}`)) {
+        throw new Error(
+          '이 시크릿에 내 멤버 recipient 가 없습니다 — `athsra migrate-envelopes --self` 1회 후 재시도.',
+        );
+      }
+      const env = await reEncryptAsMember(existing, ctx.identityPrivateKey, ctx.userId, serialized);
+      await ctx.client.putEnvelope(project, env, config);
+      return env;
+    }
+    // 신규 프로젝트 — member:self 단독 envelope 생성 (server 의 내 public key 로 wrap).
+    const keyRow = await ctx.client.getKeys();
+    if (!keyRow) {
+      throw new Error('identity key 없음 — `athsra login` 으로 재온보딩 필요.');
+    }
+    const env = await createEnvelopeAsMember(serialized, fromBase64(keyRow.public_key), ctx.userId);
+    await ctx.client.putEnvelope(project, env, config);
+    return env;
+  }
+
+  // Phase 5 — master write 는 가능하면 member:self 동반(identity 로그인 머신이 멤버 경로로 복호하는
+  // substrate). whoami/getKeys best-effort — 실패(키 미provisioning/오프라인)면 master-only 폴백.
+  const self = await selfMember(ctx);
+
   // opts.kdfParams 명시 = rotate-master 의 의도적 reset (ENTERPRISE_KDF 마이그레이션):
-  // 새 envelope 를 만들어 모든 service recipient 를 의도적으로 폐기 (master pw 재확립
-  // = scoped 신뢰 reset). routine write 와 구분되는 유일한 신호.
+  // 새 envelope 를 만들어 모든 service recipient 를 의도적으로 폐기. master(+self) recipient 만.
   if (opts?.kdfParams) {
-    const env = await createEnvelopeV2(serialized, ctx.masterPw, { kdfParams: opts.kdfParams });
-    await ctx.client.putEnvelope(project, env);
+    const env = self
+      ? await createEnvelopeWithSelf(serialized, ctx.masterPw, self.publicKey, self.userId, {
+          kdfParams: opts.kdfParams,
+        })
+      : await createEnvelopeV2(serialized, ctx.masterPw, { kdfParams: opts.kdfParams });
+    await ctx.client.putEnvelope(project, env, config);
     return env;
   }
 
   // routine write (set/unset/mcp/sync): 기존 v2 envelope 가 있으면 본문만 재암호화해
   // kdf_params 와 모든 recipient (service token 포함) 를 보존한다. createEnvelopeV2 로
   // 새로 만들면 service recipient 가 silent 삭제되고 kdf 가 DEFAULT(64MB) 로 downgrade 됨.
-  const existing = await ctx.client.getEnvelope(project);
+  // config 전파 필수 — 생략 시 default envelope 를 읽어 다른 환경의 recipient 로 덮어쓰는 버그.
+  const existing = await ctx.client.getEnvelope(project, config);
   if (existing && existing.version === 2) {
     try {
-      const env = await reEncryptEnvelopeBody(existing, ctx.masterPw, serialized);
-      await ctx.client.putEnvelope(project, env);
+      const reenc = await reEncryptEnvelopeBody(existing, ctx.masterPw, serialized);
+      // lazy self-grant: member:self 부재 시 1회 추가 (identity 복호 substrate). 실패=body-only.
+      const env = await ensureSelfRecipient(ctx, reenc, self);
+      await ctx.client.putEnvelope(project, env, config);
       return env;
     } catch (masterErr) {
       // Slice 6c — master(owner) 가 아니면 member 경로: 내 X25519 키로 DEK 얻어 본문만 재암호
@@ -149,14 +237,16 @@ export async function writePlain(
       const priv = await memberPrivateKey(ctx);
       if (!priv) throw masterErr;
       const env = await reEncryptAsMember(existing, priv, memberUserId, serialized);
-      await ctx.client.putEnvelope(project, env);
+      await ctx.client.putEnvelope(project, env, config);
       return env;
     }
   }
 
-  // 신규 프로젝트 또는 v1 (recipients[] 없음) → 새 v2 (DEFAULT_KDF). v1 의 enterprise
-  // 마이그레이션은 rotate-master / service-token create (migrateV1ToV2) 경로가 담당.
-  const env = await createEnvelopeV2(serialized, ctx.masterPw);
-  await ctx.client.putEnvelope(project, env);
+  // 신규 프로젝트 또는 v1 (recipients[] 없음) → 새 v2 (DEFAULT_KDF). master(+self) recipient.
+  // v1 의 enterprise 마이그레이션은 rotate-master / service-token create (migrateV1ToV2) 가 담당.
+  const env = self
+    ? await createEnvelopeWithSelf(serialized, ctx.masterPw, self.publicKey, self.userId)
+    : await createEnvelopeV2(serialized, ctx.masterPw);
+  await ctx.client.putEnvelope(project, env, config);
   return env;
 }

package/src/lib/identity-key.ts

@@ -6,6 +6,7 @@
  * crypto 는 @athsra/crypto/member (subpath — worker 번들 격리).
  */
 import { toBase64 } from '@athsra/crypto';
+import { parseSealedBox, unseal } from '@athsra/crypto/device';
 import { generateIdentityKeypair, unwrapPrivateKey, wrapPrivateKey } from '@athsra/crypto/member';
 import type { AthsraClient, IdentityKeyRewrap } from './client.ts';
 
@@ -57,3 +58,23 @@ export async function rewrapForRotation(
     kdf_params: rewrapped.kdfParams,
   };
 }
+
+/**
+ * Phase 5 — device-login(identity) poll 의 sealed_identity_key(SealedBox JSON)를 디바이스 privkey
+ * 로 unseal → identity private key (base64). payload.user_id 를 poll 응답 user_id 와 대조해 키
+ * 혼선/스왑을 수령 시점에 차단한다. 변조·타 디바이스 키·user_id 불일치는 전부 throw.
+ */
+export async function unsealIdentityKey(
+  sealedJson: string,
+  devicePrivateKey: Uint8Array,
+  expectedUserId: number,
+): Promise<string> {
+  const box = parseSealedBox(sealedJson);
+  const payload = await unseal(box, devicePrivateKey);
+  if (payload.user_id !== expectedUserId) {
+    throw new Error(
+      `sealed identity user_id 불일치 (${payload.user_id} ≠ ${expectedUserId}) — 재시도 또는 \`athsra login\`.`,
+    );
+  }
+  return payload.identity_private_key;
+}

package/src/lib/keyring.ts

@@ -72,6 +72,31 @@ export function clearDeviceToken(project: string): void {
   }
 }
 
+/**
+ * Phase 5 (2026-06-12) — identity 디바이스 모드. `athsra login`(identity) 이 device flow 로
+ * 수령·unseal 한 identity X25519 private key (base64 32B) 를 머신 전역 slot 에 저장. master pw 가
+ * 이 머신에 없어도 멤버 경로로 envelope 복호. loadAuthContext 의 identity 모드가 조회.
+ */
+export function setIdentityKey(machineId: string, privateKeyB64: string): void {
+  entry(`identity-priv:${machineId}`).setPassword(privateKeyB64);
+}
+
+export function getIdentityKey(machineId: string): string | null {
+  try {
+    return entry(`identity-priv:${machineId}`).getPassword();
+  } catch {
+    return null;
+  }
+}
+
+export function clearIdentityKey(machineId: string): void {
+  try {
+    entry(`identity-priv:${machineId}`).deletePassword();
+  } catch {
+    /* ignore */
+  }
+}
+
 export interface ProbeResult {
   ok: boolean;
   error?: string;

package/src/lib/mcp-register.ts

@@ -0,0 +1,223 @@
+/**
+ * mcp-register.ts — Phase 5 B6. MCP client 설정 파일에 athsra server entry 를 등록/갱신.
+ *
+ * `scripts/register-athsra-mcp.ts` 의 detectIndent/registerInJson 에서 이동·일반화 —
+ * `athsra mcp install` (제품 표면) 과 스크립트(thin wrapper)가 같은 코어를 소비.
+ *
+ * 원칙:
+ *   - **최소 diff**: 기존 파일은 텍스트 수준 삽입/치환 (indent 감지·보존, 타 entry 재직렬화 X).
+ *   - **upsert**: 미등록 → 추가, 등록 + 내용 상이(env 등) → athsra entry 만 치환, 동일 → no-op.
+ *   - 클라이언트별 스키마: claude/cursor = `mcpServers`, vscode = `servers` (+type:stdio).
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type McpClient = 'claude' | 'cursor' | 'vscode';
+export type McpScope = 'project' | 'user';
+
+export interface AthsraServerEntry {
+  type?: 'stdio';
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+}
+
+/** 클라이언트별 athsra entry. cursor 는 type 필드 미사용 관례, claude/vscode 는 stdio 명시. */
+export function buildEntry(
+  client: McpClient,
+  opts: { write?: boolean; admin?: boolean; readValues?: boolean } = {},
+): AthsraServerEntry {
+  const entry: AthsraServerEntry = { command: 'athsra', args: ['mcp'] };
+  if (client !== 'cursor') entry.type = 'stdio';
+  const env: Record<string, string> = {};
+  if (opts.write) env.ATHSRA_MCP_WRITE = '1';
+  if (opts.admin) env.ATHSRA_MCP_ADMIN = '1';
+  if (opts.readValues) env.ATHSRA_MCP_READ_VALUES = '1';
+  if (Object.keys(env).length > 0) entry.env = env;
+  return entry;
+}
+
+export interface ResolvedTarget {
+  path: string;
+  rootKey: 'mcpServers' | 'servers';
+}
+
+/** 설정 파일 위치 + root key. vscode 는 project scope 만 (.vscode/mcp.json — user 위치 플랫폼 의존). */
+export function resolveTarget(
+  client: McpClient,
+  scope: McpScope,
+  targetDir: string,
+): ResolvedTarget | { error: string } {
+  if (scope === 'user') {
+    if (client === 'claude') {
+      return { path: join(homedir(), '.claude.json'), rootKey: 'mcpServers' };
+    }
+    if (client === 'cursor') {
+      return { path: join(homedir(), '.cursor', 'mcp.json'), rootKey: 'mcpServers' };
+    }
+    return { error: 'vscode 는 user scope 미지원 — project scope (.vscode/mcp.json) 사용' };
+  }
+  if (client === 'claude') return { path: join(targetDir, '.mcp.json'), rootKey: 'mcpServers' };
+  if (client === 'cursor') {
+    return { path: join(targetDir, '.cursor', 'mcp.json'), rootKey: 'mcpServers' };
+  }
+  return { path: join(targetDir, '.vscode', 'mcp.json'), rootKey: 'servers' };
+}
+
+/** 기존 파일의 1-level indent 감지 (tab 또는 space). 기본 tab (.mcp.json universe 표준). */
+export function detectIndent(raw: string): string {
+  const m = raw.match(/\n([\t ]+)"/);
+  if (!m?.[1]) return '\t';
+  return m[1][0] === '\t' ? '\t' : m[1];
+}
+
+interface ConfigJson {
+  [k: string]: unknown;
+}
+
+export interface UpsertResult {
+  changed: boolean;
+  reason: string;
+}
+
+/** key("…") 다음에 오는 object 의 `{…}` 범위를 string-aware brace matching 으로 찾는다. */
+function findKeyObjectBounds(
+  raw: string,
+  quotedKey: string,
+  from = 0,
+): { keyStart: number; open: number; close: number } | null {
+  const ki = raw.indexOf(quotedKey, from);
+  if (ki < 0) return null;
+  const open = raw.indexOf('{', ki);
+  if (open < 0) return null;
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = open; i < raw.length; i++) {
+    const ch = raw[i];
+    if (esc) {
+      esc = false;
+      continue;
+    }
+    if (ch === '\\') {
+      esc = true;
+      continue;
+    }
+    if (ch === '"') {
+      inStr = !inStr;
+      continue;
+    }
+    if (inStr) continue;
+    if (ch === '{') depth++;
+    else if (ch === '}') {
+      depth--;
+      if (depth === 0) return { keyStart: ki, open, close: i };
+    }
+  }
+  return null;
+}
+
+/** athsra entry 수동 직렬화 — args 단일라인 등 기존 .mcp.json 관례 유지 (JSON.stringify 다행 배열 회피). */
+function serializeEntry(entry: AthsraServerEntry, indent: string, level: number): string {
+  const pad = indent.repeat(level);
+  const inner = indent.repeat(level + 1);
+  const fields: string[] = [];
+  if (entry.type) fields.push(`${inner}"type": "stdio"`);
+  fields.push(`${inner}"command": ${JSON.stringify(entry.command)}`);
+  fields.push(`${inner}"args": [${entry.args.map((a) => JSON.stringify(a)).join(', ')}]`);
+  if (entry.env) {
+    const envInner = indent.repeat(level + 2);
+    const envLines = Object.entries(entry.env)
+      .map(([k, v]) => `${envInner}${JSON.stringify(k)}: ${JSON.stringify(v)}`)
+      .join(',\n');
+    fields.push(`${inner}"env": {\n${envLines}\n${inner}}`);
+  }
+  return `${pad}"athsra": {\n${fields.join(',\n')}\n${pad}}`;
+}
+
+/** sorted-key stringify — entry 동일성 비교 (파일 내 key 순서 무관). */
+function stable(v: unknown): string {
+  if (Array.isArray(v)) return `[${v.map(stable).join(',')}]`;
+  if (v !== null && typeof v === 'object') {
+    const o = v as Record<string, unknown>;
+    return `{${Object.keys(o)
+      .sort()
+      .map((k) => `${JSON.stringify(k)}:${stable(o[k])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(v);
+}
+
+/** 파일 부재 시의 신규 내용 (tab indent, universe 표준). */
+export function freshFileContent(
+  rootKey: 'mcpServers' | 'servers',
+  entry: AthsraServerEntry,
+): string {
+  return `{\n\t"${rootKey}": {\n${serializeEntry(entry, '\t', 2)}\n\t}\n}\n`;
+}
+
+/**
+ * 기존 설정 텍스트에 athsra entry upsert (최소 diff).
+ *   - 미등록 → rootKey 블록 마지막 entry 뒤 삽입 (comma 처리)
+ *   - 등록 + 동일 → { changed:false, reason:'already registered' }
+ *   - 등록 + 상이 → athsra entry 범위만 치환 (reason:'updated')
+ *   - rootKey 블록 부재 → parse 기반 전체 재직렬화 fallback
+ */
+export function upsertServerEntry(
+  raw: string,
+  rootKey: 'mcpServers' | 'servers',
+  entry: AthsraServerEntry,
+): { result: UpsertResult; output?: string } {
+  const json = JSON.parse(raw) as ConfigJson;
+  const root = (json[rootKey] ?? {}) as Record<string, unknown>;
+  const indent = detectIndent(raw);
+
+  const existing = root.athsra;
+  if (existing !== undefined && stable(existing) === stable(entry)) {
+    return { result: { changed: false, reason: 'already registered' } };
+  }
+
+  const rootBounds = findKeyObjectBounds(raw, `"${rootKey}"`);
+  if (!rootBounds) {
+    // rootKey 블록 미발견 — fallback: parse 기반 재직렬화.
+    json[rootKey] = { ...root, athsra: entry };
+    return {
+      result: {
+        changed: true,
+        reason: existing ? 'updated (reserialized)' : 'added (reserialized)',
+      },
+      output: `${JSON.stringify(json, null, indent)}\n`,
+    };
+  }
+
+  if (existing !== undefined) {
+    // 치환 — athsra entry 범위만 교체 (선행 indent 는 기존 텍스트 그대로).
+    const entryBounds = findKeyObjectBounds(raw, '"athsra"', rootBounds.open);
+    if (!entryBounds || entryBounds.keyStart > rootBounds.close) {
+      json[rootKey] = { ...root, athsra: entry };
+      return {
+        result: { changed: true, reason: 'updated (reserialized)' },
+        output: `${JSON.stringify(json, null, indent)}\n`,
+      };
+    }
+    const pad = indent.repeat(2);
+    const replacement = serializeEntry(entry, indent, 2).slice(pad.length);
+    const output =
+      raw.slice(0, entryBounds.keyStart) + replacement + raw.slice(entryBounds.close + 1);
+    return { result: { changed: true, reason: 'updated' }, output };
+  }
+
+  // 삽입 — rootKey 닫는 `}` 직전, 마지막 entry 뒤 (comma 처리).
+  const entryText = serializeEntry(entry, indent, 2);
+  const entryCount = Object.keys(root).length;
+  const head = raw.slice(0, rootBounds.close);
+  const tail = raw.slice(rootBounds.close);
+  const headTrimmed = head.replace(/\s*$/, '');
+  const trailingWs = head.slice(headTrimmed.length);
+
+  const output =
+    entryCount === 0
+      ? `${headTrimmed}\n${entryText}${trailingWs}${tail}`
+      : `${headTrimmed},\n${entryText}${trailingWs}${tail}`;
+  return { result: { changed: true, reason: 'added' }, output };
+}