aiakiv 0.1.0 → 0.2.0

package/dist/doctor.js

@@ -1,7 +1,9 @@
 // `aiakiv doctor [--client …] [--dir <폴더>] [--out <파일>]` — 설정 파일, 클라이언트 등록 목록,
 // 스킬 위치를 확인하고 키로 묶인 연결은 get_save_target 을 직접 불러 본다. 결과는 마크다운 파일로.
-// bind 가 쓰는 나머지(폴더 스킬 일곱 개, Claude 의 enabledMcpjsonServers)도 그 폴더에 있는지 본다.
+// bind 가 쓰는 나머지(폴더 스킬 여덟 개, Claude 의 enabledMcpjsonServers)도 그 폴더에 있는지 본다.
 // 전역 등록 목록은 bind 와 상관없지만 겹치는 연결을 사람에게 알리려고 계속 본다.
+// setup 이 쓰는 전역 파일(Gemini CLI `~/.gemini/settings.json`, Antigravity `~/.gemini/config/mcp_config.json`)의
+// 키 항목은 get_save_target 으로 binding main 인지 본다(clients/global.ts).
 //
 // 키와 토큰 평문은 화면에도 파일에도 쓰지 않는다(앞 8자 + …). 클라이언트 목록은 다른 서비스의
 // 주소(키가 든 주소가 있을 수 있다)를 옮기지 않도록 AiAkiv 항목만 고른다.
@@ -10,15 +12,26 @@ import { join, resolve } from "node:path";
 import { classifyClaudeName, CLAUDE_KIND_LABEL, findClaude, installedPluginIds, parseClaudeMcpList, } from "./clients/claude.js";
 import { codexHome, findCodex, parseCodexMcpList } from "./clients/codex.js";
 import { cursorGlobalConfig } from "./clients/cursor.js";
+import { globalConfigPath, GLOBAL_CLIENT_IDS, GLOBAL_SERVER_NAME } from "./clients/global.js";
 import { CLAUDE_FOLDER_SETTINGS, CLAUDE_FOLDER_SETTINGS_LOCAL, CLIENT_IDS, FOLDER_CONFIG, looksLikeAiAkiv, } from "./clients/types.js";
 import { jsonServers, jsonStringArray, readJsonObject } from "./config/json.js";
 import { readTomlObject, tomlServers } from "./config/toml.js";
+import { CONSOLE_KEY_FILE, expiryText, LEGACY_KEY_FILE_MESSAGE, readConsoleKeyFile } from "./consoleKeyFile.js";
 import { probeSaveTarget } from "./mcpProbe.js";
 import { failReason } from "./proc.js";
 import { FOLDER_SKILLS_DIR, SKILL_NAMES, SKILLS_AGENT, skillsManualCommand } from "./skills.js";
 import { controlBase, mcpBase } from "./urls.js";
 import { VERSION } from "./version.js";
 export const DEFAULT_REPORT = "aiakiv-verification-test.md";
+export const DOCTOR_CLIENT_IDS = [...CLIENT_IDS, "antigravity"];
+/** 폴더 고정(bind)이 있는 클라이언트인가. */
+export function isFolderClient(c) {
+    return CLIENT_IDS.includes(c);
+}
+/** setup 이 전역 파일을 쓰는 클라이언트인가. */
+function isSetupClient(c) {
+    return GLOBAL_CLIENT_IDS.includes(c);
+}
 /** 키 가리기: 앞 8자 + …(짧으면 전부 가린다). */
 export function maskSecret(v) {
     return v.length > 12 ? `${v.slice(0, 8)}…` : "…";
@@ -77,12 +90,23 @@ export function scanConfigs(ctx, dir, clients) {
     const entries = [];
     const notes = [];
     const files = [];
-    for (const c of clients)
-        files.push({ client: c, scope: "폴더", file: join(dir, FOLDER_CONFIG[c]) });
+    for (const c of clients) {
+        if (isFolderClient(c))
+            files.push({ client: c, scope: "폴더", file: join(dir, FOLDER_CONFIG[c]) });
+    }
     if (clients.includes("cursor"))
         files.push({ client: "cursor", scope: "전역", file: cursorGlobalConfig(ctx) });
-    if (clients.includes("gemini")) {
-        files.push({ client: "gemini", scope: "전역", file: join(ctx.home, ".gemini", "settings.json") });
+    for (const c of GLOBAL_CLIENT_IDS) {
+        if (!clients.includes(c))
+            continue;
+        const file = globalConfigPath(ctx, c);
+        // 폴더가 홈이면 폴더의 `.gemini/settings.json` 이 곧 전역 파일이다. 전역으로 한 번만 본다
+        // (setup 이 쓴 계정 전체 키를 폴더 고정 키로 잘못 읽지 않게).
+        for (let i = files.length - 1; i >= 0; i -= 1) {
+            if (files[i].scope === "폴더" && resolve(files[i].file) === resolve(file))
+                files.splice(i, 1);
+        }
+        files.push({ client: c, scope: "전역", file });
     }
     for (const f of files) {
         if (!existsSync(f.file))
@@ -184,6 +208,8 @@ export function skillLocations(ctx, dir) {
         join(ctx.home, ".agents", "skills"),
         join(ctx.home, ".cursor", "skills"),
         join(ctx.home, ".gemini", "skills"),
+        join(ctx.home, ".gemini", "config", "skills"),
+        join(ctx.home, ".gemini", "antigravity-cli", "skills"),
         join(codexHome(ctx), "skills"),
         join(dir, ".claude", "skills"),
         join(dir, ".agents", "skills"),
@@ -208,19 +234,29 @@ export function skillLocations(ctx, dir) {
     }
     return out;
 }
-function probeLine(p) {
+/** setup 이 쓴 전역 항목인가(Gemini CLI, Antigravity 의 전역 파일의 `AiAkiv`). 이 항목의 키는 binding main 이어야
+ * 한다. 같은 파일의 다른 이름(`AiAkiv-<프로젝트>`, 홈 폴더에서 bind 한 경우 등)은 프로젝트 키로 본다. */
+function isSetupEntry(e) {
+    return e.scope === "전역" && isSetupClient(e.client) && e.name === GLOBAL_SERVER_NAME;
+}
+function probeLine(p, e) {
     if (p.ok)
         return `팀 ${p.team ?? "?"}, 프로젝트 ${p.project ?? "?"}, binding ${p.binding ?? "?"}`;
-    const hint = p.status === 401
-        ? " (키가 폐기됐거나 틀립니다. 같은 프로젝트를 다른 폴더에서 bind 하면 이전 키가 폐기되니, 이 폴더에서 bind 를 다시 하세요)"
-        : "";
+    let hint = "";
+    if (p.status === 401) {
+        hint = isSetupEntry(e)
+            ? ` (키가 폐기됐거나 틀립니다. 계정 전체 키는 한 사람에게 하나라 다른 PC 에서 setup 을 하면 이 키가 폐기됩니다. ` +
+                `npx aiakiv setup --client ${e.client} 로 다시 받으세요)`
+            : " (키가 폐기됐거나 틀립니다. 같은 프로젝트를 다른 폴더에서 bind 하면 이전 키가 폐기되니, 이 폴더에서 bind 를 다시 하세요)";
+    }
     return `실패${p.status ? `(${p.status})` : ""}: ${p.reason}${hint}`;
 }
-/** bind 가 스킬을 넣는 폴더 자리마다 일곱 개가 있는지. */
+/** bind 가 스킬을 넣는 폴더 자리마다 여덟 개가 있는지. 폴더 고정이 없는 클라이언트(antigravity)는 뺀다. */
 export function folderSkillChecks(dir, clients) {
     const byRel = new Map();
-    for (const c of clients)
+    for (const c of clients.filter(isFolderClient)) {
         byRel.set(FOLDER_SKILLS_DIR[c], [...(byRel.get(FOLDER_SKILLS_DIR[c]) ?? []), c]);
+    }
     return [...byRel].map(([rel, cs]) => {
         const names = aiakivSkillsIn(join(dir, ...rel.split("/")));
         return { rel, clients: cs, names, missing: SKILL_NAMES.filter((n) => !names.includes(n)) };
@@ -251,6 +287,21 @@ export function claudeEnabledChecks(dir, entries) {
         notes,
     };
 }
+/** `.aiakiv/console.json`(console key 가 쓴 계정 키 파일)이 있으면 한 줄. 평문은 싣지 않는다. 없으면 null.
+ * 옛 판(R0, 프로젝트 키를 담은 파일)이면 다시 받으라고 적는다(console, dashboard 도 그 파일은 쓰지 않는다). */
+function consoleKeyLine(dir) {
+    try {
+        const f = readConsoleKeyFile(dir);
+        if (!f)
+            return null;
+        if (f.legacy)
+            return `${CONSOLE_KEY_FILE}: ${LEGACY_KEY_FILE_MESSAGE}`;
+        return `CLI 계정 키(key_id ${f.key_id ?? maskSecret(f.key)}, 만료 ${expiryText(f.expires_at)}): ${CONSOLE_KEY_FILE}`;
+    }
+    catch (e) {
+        return `CLI 계정 키 파일을 읽을 수 없습니다: ${e.message}`;
+    }
+}
 function howLabel(e) {
     if (e.auth === "apikey")
         return `${AUTH_LABEL[e.auth]} ${e.keyMasked}`;
@@ -267,7 +318,7 @@ export async function runDoctor(ctx, opts) {
         ctx.err(`폴더가 없습니다: ${dir}`);
         return 1;
     }
-    const clients = opts.clients?.length ? opts.clients : [...CLIENT_IDS];
+    const clients = opts.clients?.length ? opts.clients : [...DOCTOR_CLIENT_IDS];
     const outFile = opts.out ? resolve(ctx.cwd, opts.out) : join(dir, DEFAULT_REPORT);
     const scan = scanConfigs(ctx, dir, clients);
     const probes = new Map();
@@ -285,6 +336,7 @@ export async function runDoctor(ctx, opts) {
     const skills = skillLocations(ctx, dir);
     const folderSkills = folderSkillChecks(dir, clients);
     const enabled = claudeEnabledChecks(dir, scan.entries);
+    const consoleKey = consoleKeyLine(dir);
     const md = [];
     md.push("# AiAkiv 확인 기록", "");
     md.push(`- 일시: ${new Date().toISOString()}`);
@@ -309,12 +361,14 @@ export async function runDoctor(ctx, opts) {
     if (keyed.length) {
         for (const e of keyed) {
             const p = probes.get(e);
-            md.push(`- ${e.name}(${e.file}): ${typeof p === "string" ? p : probeLine(p)}`);
+            md.push(`- ${e.name}(${e.file}): ${typeof p === "string" ? p : probeLine(p, e)}`);
         }
     }
     else
         md.push("키로 묶인 연결이 없습니다.");
     md.push("");
+    if (consoleKey)
+        md.push("## CLI 계정 키", "", `- ${consoleKey}`, "");
     md.push("## 클라이언트 등록 목록", "");
     for (const s of lists) {
         md.push(`### ${s.title}`, "");
@@ -326,7 +380,7 @@ export async function runDoctor(ctx, opts) {
     if (skills.length) {
         for (const s of skills) {
             const missing = SKILL_NAMES.filter((n) => !s.names.includes(n));
-            md.push(`- ${s.root}: ${s.names.length}개${missing.length ? `(빠짐: ${missing.join(", ")})` : "(일곱 개 모두)"}`);
+            md.push(`- ${s.root}: ${s.names.length}개${missing.length ? `(빠짐: ${missing.join(", ")})` : "(여덟 개 모두)"}`);
         }
     }
     else
@@ -334,11 +388,13 @@ export async function runDoctor(ctx, opts) {
     md.push("");
     const skillState = (s) => !s.names.length
         ? "없음"
-        : `${s.names.length}개${s.missing.length ? `(빠짐: ${s.missing.join(", ")})` : "(일곱 개 모두)"}`;
-    md.push("## 폴더 스킬(bind 가 넣는 자리)", "");
-    for (const s of folderSkills)
-        md.push(`- ${s.rel}(${s.clients.join(", ")}): ${skillState(s)}`);
-    md.push("");
+        : `${s.names.length}개${s.missing.length ? `(빠짐: ${s.missing.join(", ")})` : "(여덟 개 모두)"}`;
+    if (folderSkills.length) {
+        md.push("## 폴더 스킬(bind 가 넣는 자리)", "");
+        for (const s of folderSkills)
+            md.push(`- ${s.rel}(${s.clients.join(", ")}): ${skillState(s)}`);
+        md.push("");
+    }
     if (enabled.checks.length || enabled.notes.length) {
         md.push("## Claude 폴더 서버 켜기(enabledMcpjsonServers)", "");
         for (const c of enabled.checks) {
@@ -360,12 +416,30 @@ export async function runDoctor(ctx, opts) {
     for (const [e, p] of probes) {
         if (typeof p === "string")
             continue;
+        if (isSetupEntry(e)) {
+            // setup 이 쓰는 계정 전체 키는 Main 을 따라간다(binding main).
+            if (p.ok && p.binding !== "main") {
+                next.push(`${e.name}(${e.client} 전역): binding 이 ${p.binding} 입니다. 계정 전체 키라면 main 이 나와야 합니다. ` +
+                    `npx aiakiv setup --client ${e.client} --new-key 로 다시 받으세요.`);
+            }
+            if (!p.ok) {
+                next.push(`${e.name}(${e.client} 전역): 키 연결이 실패했습니다. npx aiakiv setup --client ${e.client} 로 다시 받으세요.`);
+            }
+            continue;
+        }
         if (p.ok && p.binding !== "api-key") {
             next.push(`${e.name}: binding 이 ${p.binding} 입니다. 프로젝트 고정 키라면 api-key 가 나와야 합니다.`);
         }
         if (!p.ok)
             next.push(`${e.name}: 키 연결이 실패했습니다. 키가 폐기됐으면 npx aiakiv bind 로 다시 받으세요.`);
     }
+    // --client 로 setup 대상을 직접 고른 경우에만, 전역 연결이 없으면 설치 명령을 알린다(기본 전체 확인에서는
+    // 폴더만 쓰는 사람에게 소음이 된다).
+    for (const c of (opts.clients ?? []).filter(isSetupClient)) {
+        if (scan.entries.some((e) => e.scope === "전역" && e.client === c))
+            continue;
+        next.push(`${c} 전역 연결(${globalConfigPath(ctx, c)})이 없습니다. npx aiakiv setup --client ${c} 로 설치하세요.`);
+    }
     // 폴더 스킬은 그 자리를 읽는 클라이언트가 이 폴더에 고정돼 있을 때만 다음 단계로 낸다.
     for (const s of folderSkills) {
         const bound = s.clients.filter((c) => scan.entries.some((e) => e.scope === "폴더" && e.client === c));
@@ -381,9 +455,12 @@ export async function runDoctor(ctx, opts) {
             "npx aiakiv bind --client claude 를 다시 하세요.");
     }
     if (!scan.entries.length) {
-        next.push("폴더에 프로젝트를 고정하려면 npx aiakiv bind --client <클라이언트> --project <이름>");
+        if (clients.some(isFolderClient)) {
+            next.push("폴더에 프로젝트를 고정하려면 npx aiakiv bind --client <클라이언트> --project <이름>");
+        }
         if (!skills.length) {
-            next.push("전역 설치(계정 연결과 전역 스킬)는 설치 프롬프트나 플러그인 마켓으로 하세요.");
+            next.push("전역 설치는 Gemini CLI 와 Antigravity 만 npx aiakiv setup --client gemini,antigravity 로 합니다. " +
+                "그 밖은 설치 프롬프트나 플러그인 마켓을 쓰세요.");
         }
     }
     md.push("## 다음 단계", "");
@@ -404,7 +481,7 @@ export async function runDoctor(ctx, opts) {
         ctx.out("  설정 파일에 AiAkiv 연결 없음");
     for (const e of scan.entries) {
         const p = probes.get(e);
-        const tail = p === undefined ? "" : `, 확인 결과 ${typeof p === "string" ? p : probeLine(p)}`;
+        const tail = p === undefined ? "" : `, 확인 결과 ${typeof p === "string" ? p : probeLine(p, e)}`;
         ctx.out(`  [${e.scope} ${e.client}] ${e.name}: ${howLabel(e)}${tail}`);
     }
     for (const n of scan.notes)
@@ -412,7 +489,10 @@ export async function runDoctor(ctx, opts) {
     for (const s of lists)
         ctx.out(`  ${s.title}: ${s.lines.join(" / ")}`);
     ctx.out(`  스킬: ${skills.length ? skills.map((s) => `${s.root}(${s.names.length})`).join(", ") : "찾지 못함"}`);
-    ctx.out(`  폴더 스킬: ${folderSkills.map((s) => `${s.rel} ${skillState(s)}`).join(", ")}`);
+    if (folderSkills.length)
+        ctx.out(`  폴더 스킬: ${folderSkills.map((s) => `${s.rel} ${skillState(s)}`).join(", ")}`);
+    if (consoleKey)
+        ctx.out(`  ${consoleKey}`);
     for (const c of enabled.checks) {
         ctx.out(`  enabledMcpjsonServers ${c.name}: ${c.in.length ? c.in.join(", ") : "없음"}`);
     }

package/dist/handoff.js

@@ -1,8 +1,13 @@
-// 브라우저 인계로 프로젝트 키 받기(BP-165 §4).
+// 브라우저 인계로 키 받기(BP-165 §4, BP-171 §4.2).
 //
 // 1. 127.0.0.1 의 빈 포트에 작은 HTTP 서버를 연다. state 는 무작위 24바이트.
-// 2. 웹 콘솔의 인계 화면 `/account/cli/handoff?project&port&state&client[&expires_days]` 을 연다.
-// 3. 사람이 단추를 누르면 콘솔이 `http://127.0.0.1:<port>/callback?code&state` 로 돌려보낸다.
+// 2. 웹 콘솔의 인계 화면을 연다. 모양은 셋이다.
+//    - 프로젝트 키(bind): `/account/cli/handoff?project&port&state&client[&expires_days]`
+//    - 계정 키(console key): `/account/cli/handoff?kind=account&port&state&client=cli[&expires_days]`.
+//      project 는 보내지 않는다(계정 키는 팀도 저장 좌표도 없다).
+//    - 계정 전체 기억 키(setup): `/account/cli/handoff?kind=dynamic&port&state&client=<클라이언트들>[&expires_days]`.
+//      Main 을 따라가는 키라 project 를 보내지 않는다(BP-165 P6).
+// 3. 사람이 버튼을 누르면 콘솔이 `http://127.0.0.1:<port>/callback?code&state` 로 돌려보낸다.
 //    state 가 다르면 400 을 주고 계속 기다린다(엉뚱한 요청 하나로 흐름이 끊기지 않게).
 // 4. `POST /api/cli/exchange {code, state, port}` 로 코드를 키로 바꾼다. 평문은 이 응답에만 있다.
 //
@@ -15,7 +20,16 @@ export function newState() {
     return randomBytes(24).toString("base64url");
 }
 export function handoffUrl(control, p) {
-    const q = new URLSearchParams({ project: p.project, port: String(p.port), state: p.state });
+    const q = new URLSearchParams();
+    if (p.kind === "account" || p.kind === "dynamic")
+        q.set("kind", p.kind);
+    else {
+        if (!p.project)
+            throw new Error("프로젝트 키 인계에는 프로젝트 이름이 필요합니다.");
+        q.set("project", p.project);
+    }
+    q.set("port", String(p.port));
+    q.set("state", p.state);
     if (p.expiresDays !== undefined)
         q.set("expires_days", String(p.expiresDays));
     q.set("client", p.client);
@@ -94,6 +108,10 @@ export function startLoopback(state, timeoutMs = HANDOFF_TIMEOUT_MS) {
         });
     });
 }
+/** 계정 키를 달라고 했는데 응답이 계정 키가 아닐 때(서버가 옛 판). */
+export const ACCOUNT_KEY_UNSUPPORTED = "서버가 계정 키를 지원하지 않습니다. 웹 콘솔을 쓰세요.";
+/** 계정 전체 기억 키를 달라고 했는데 응답이 그 키가 아닐 때(서버가 옛 판). */
+export const DYNAMIC_KEY_UNSUPPORTED = "서버가 계정 전체 키를 아직 지원하지 않습니다. 받은 키는 쓰지 않았습니다. 웹 콘솔의 설치 안내를 쓰세요.";
 export class HandoffError extends Error {
 }
 async function shortReason(res) {
@@ -114,7 +132,10 @@ async function shortReason(res) {
         return "";
     }
 }
-export async function exchangeCode(fetchImpl, control, body) {
+/** `expect`: 어떤 키를 받으려 했는가. "project" 면 응답에 project 가 있어야 하고, "account" 면
+ * 응답 kind 가 "account" 여야 한다(아니면 ACCOUNT_KEY_UNSUPPORTED, 받은 평문은 버린다).
+ * "dynamic" 이면 응답 kind 가 "dynamic" 이어야 한다(아니면 DYNAMIC_KEY_UNSUPPORTED). */
+export async function exchangeCode(fetchImpl, control, body, expect = "project") {
     let res;
     try {
         res = await fetchImpl(`${control}/api/cli/exchange`, {
@@ -147,10 +168,38 @@ export async function exchangeCode(fetchImpl, control, body) {
     }
     const o = j;
     // 필드 확인. 오류 문구에 응답 값을 넣지 않는다(평문이 들어 있다).
-    for (const k of ["key_id", "plaintext", "project"]) {
+    const required = expect === "project" ? ["key_id", "plaintext", "project"] : ["key_id", "plaintext"];
+    for (const k of required) {
         if (typeof o?.[k] !== "string" || !o[k]) {
             throw new HandoffError(`키 교환 응답에 ${k} 가 없습니다.`);
         }
     }
+    if (expect === "account" && o.kind !== "account")
+        throw new HandoffError(ACCOUNT_KEY_UNSUPPORTED);
+    if (expect === "dynamic" && o.kind !== "dynamic")
+        throw new HandoffError(DYNAMIC_KEY_UNSUPPORTED);
     return o;
 }
+/** 교환 응답의 `scopes`(서버는 "read,write" 나 "manage" 같은 글자, 옛 모양은 배열)를 목록으로. */
+export function scopeList(scopes) {
+    const raw = Array.isArray(scopes) ? scopes : typeof scopes === "string" ? scopes.split(",") : [];
+    return raw.map((s) => String(s).trim()).filter(Boolean);
+}
+/** 앞선 키를 폐기했다는 안내. 0, 빈 목록, 숫자나 목록이 아니면 null(줄을 내지 않는다).
+ * 프로젝트 키(bind)는 같은 프로젝트의 키, 계정 키(console key)는 그 사람의 앞선 계정 키,
+ * 계정 전체 키(setup)는 그 사람의 앞선 계정 전체 키(다른 PC 것 포함)가 폐기된다.
+ * `n` 이 키 id 목록이면 개수와 함께 id 를 적는다(id 는 평문이 아니다). */
+export function supersededNotice(n, kind = "project") {
+    const ids = Array.isArray(n) ? n.filter((x) => typeof x === "string" && !!x) : [];
+    const count = Array.isArray(n) ? n.length : typeof n === "number" ? n : 0;
+    if (!(count > 0))
+        return null;
+    const idText = ids.length ? `(키 id ${ids.join(", ")})` : "";
+    if (kind === "dynamic") {
+        return `앞선 계정 전체 키 ${count}개${idText}를 폐기했습니다. 다른 PC 에 넣어 둔 계정 전체 키도 더는 쓸 수 없으니, ` +
+            "그 PC 에서도 setup 을 다시 하세요.";
+    }
+    return kind === "account"
+        ? `앞선 계정 키 ${count}개${idText}를 폐기했습니다.`
+        : `이전 키 ${count}개${idText}를 폐기했습니다. 다른 폴더에 같은 프로젝트 키를 넣어 두었다면 그 폴더도 다시 bind 하세요.`;
+}

package/dist/main.js

@@ -1,37 +1,96 @@
 // 인자 해석과 명령 고르기. 인자 해석은 Node 내장 util.parseArgs(외부 라이브러리 없음).
 import { parseArgs } from "node:util";
+import { GLOBAL_CLIENT_IDS, SETUP_ONLY_GLOBAL_CLIENTS } from "./clients/global.js";
 import { CLIENT_IDS } from "./clients/types.js";
 import { runBind } from "./bind.js";
-import { DEFAULT_REPORT, runDoctor } from "./doctor.js";
+import { ConsoleUsageError, runConsole, runConsoleKey } from "./console.js";
+import { runDashboard } from "./dashboard.js";
+import { DEFAULT_REPORT, DOCTOR_CLIENT_IDS, runDoctor } from "./doctor.js";
+import { runSetup } from "./setup.js";
 import { DEFAULT_SKILLS_TARBALL_URL } from "./skills.js";
 import { DEFAULT_CONTROL_URL, DEFAULT_MCP_URL } from "./urls.js";
 import { VERSION } from "./version.js";
-export const HELP = `aiakiv ${VERSION}: 폴더에 AiAkiv 프로젝트를 고정하고 확인하는 명령
+export const HELP = `aiakiv ${VERSION}: 폴더에 AiAkiv 프로젝트를 고정하고 확인하고, 전역 설치와 콘솔 작업을 하는 명령
 
 사용법:
   npx aiakiv bind   --client codex|claude|gemini|cursor --project <이름> [--dir <폴더>]
                     [--expires-days N] [--no-browser] [--no-skills]
+  npx aiakiv setup  --client gemini|antigravity[,…] [--expires-days N] [--no-browser] [--no-skills] [--new-key]
   npx aiakiv doctor [--client <클라이언트>[,…]] [--dir <폴더>] [--out ${DEFAULT_REPORT}] [--no-probe]
+  npx aiakiv console <액션> [--data '<json>' | --data @파일.json] [--json] [--dir <폴더>] [--yes]
+  npx aiakiv console describe [--json] [--dir <폴더>]
+  npx aiakiv console key [--expires-days N] [--dir <폴더>] [--no-browser]
+  npx aiakiv dashboard [--json] [--dir <폴더>]
 
 bind    폴더에 프로젝트를 고정합니다. 웹 콘솔의 "폴더 ZIP 받기" 와 같은 한 벌을 그 폴더에 직접 씁니다.
-        claude, cursor 는 ?project= 주소(OAuth)를 쓰고, codex, gemini 는 브라우저에서 확인 단추를 눌러
+        claude, cursor 는 ?project= 주소(OAuth)를 쓰고, codex, gemini 는 브라우저에서 확인 버튼을 눌러
         프로젝트 키를 받아 씁니다. 키 평문은 화면에 내지 않고 그 폴더의 설정 파일에만 씁니다.
-        함께 쓰는 것: 폴더 스킬 일곱 개(claude 는 .claude/skills, 나머지는 .agents/skills,
+        함께 쓰는 것: 폴더 스킬 여덟 개(claude 는 .claude/skills, 나머지는 .agents/skills,
         --no-skills 면 건너뜀), claude 는 .claude/settings.json 의 enabledMcpjsonServers,
         codex, gemini 는 키가 든 설정 파일을 .gitignore 에(git 저장소이거나 .gitignore 가 있을 때).
+        Antigravity 는 앱 전체에 설정 하나라 폴더 고정이 없습니다(setup 을 쓰세요).
+setup   Gemini CLI 와 Antigravity 의 전역 설치를 합니다. 브라우저에서 확인 버튼을 눌러 Main(저장 대상)을
+        따라가는 계정 전체 기억 키를 받고, 고른 클라이언트 모두의 전역 설정에 서버 이름 AiAkiv 로 씁니다.
+        Gemini CLI 는 ~/.gemini/settings.json(httpUrl), Antigravity 는 ~/.gemini/config/mcp_config.json
+        (serverUrl). 전역 스킬도 씁니다(Gemini CLI 는 ~/.gemini/skills, Antigravity 는 ~/.gemini/config/skills
+        와, ~/.gemini/antigravity-cli 가 있으면 그 아래 skills. --no-skills 면 건너뜀).
+        계정 전체 키는 한 사람에게 하나만 살아 있어, 새로 받으면 앞선 키(다른 PC 것 포함)는 폐기됩니다.
+        그래서 두 전역 파일에 쓸 수 있는 키(binding main)가 이미 있으면 브라우저를 열지 않고 그 키를
+        다시 씁니다. --new-key 면 새로 받습니다. --expires-days 가 없으면 만료가 없습니다.
 doctor  설정 파일, 클라이언트 등록 목록, 스킬 위치를 확인하고 결과를 마크다운 파일로 씁니다.
         키로 묶인 연결은 get_save_target 을 직접 불러 팀, 프로젝트, binding 을 적습니다.
+        --client 는 bind 의 넷과 antigravity 를 받습니다(기본은 모두). setup 이 쓴 전역 키는 binding 이
+        main 이어야 합니다.
+console 웹 콘솔의 작업(팀, 초대, 프로젝트, Main 전환, 연결, 카드 등)을 실행합니다. 액션 이름과
+        인자는 console describe 가 보여 줍니다. 별칭: teams, projects, links, permissions.
+        읽기는 bind 가 받은 프로젝트 키(그 키의 팀만)나 계정 키로 됩니다. 쓰기는 계정 키와, 콘솔
+        "AI 권한" 에서 켠 권한이 둘 다 있어야 합니다. 접근 범위를 넓히는 쓰기는 실행 전에 한 번 묻고,
+        터미널이 아니면 --yes 가 있어야 실행합니다. --json 은 서버 응답을 그대로 냅니다(오류 응답도).
+console key
+        계정 관리 키를 브라우저 확인으로 받아 .aiakiv/console.json 에 씁니다. 이 키로는 기억을
+        읽거나 쓸 수 없고 관리 작업만 합니다. 기본 만료 90일. 프로젝트나 팀을 고르지 않고, 속한
+        모든 팀을 다룹니다(.gitignore 에 /.aiakiv/ 를 더합니다). 다시 받으면 앞선 계정 키는 폐기됩니다.
+dashboard
+        팀, 프로젝트, 저장 대상, 켜진 권한, 연결, 카드, 최근 저장 대상 이력을 한 화면에 보입니다.
+        한 칸이 실패해도 나머지는 그립니다. 계정 키로는 저장 대상을 읽지 않고, 그 폴더에 프로젝트
+        키가 있으면 그 키로 확인합니다.
 
-전역 설치(계정 연결과 전역 스킬)는 이 명령이 하지 않습니다. 설치 프롬프트나 플러그인 마켓을 쓰세요.
+console 과 dashboard 가 키를 찾는 순서: 환경 변수 AIAKIV_API_KEY, <폴더>/.aiakiv/console.json(계정 키),
+<폴더>의 .codex/config.toml 과 .gemini/settings.json(프로젝트 키). 키 평문은 화면에 내지 않고 키 id 와
+종류만 보입니다.
+
+console 과 dashboard 의 종료 코드:
+  0  성공
+  1  서버 오류(500, 연결 실패, 읽을 수 없는 응답)
+  2  사용 오류(인자, --yes 없음, 키 없음)
+  3  인증 실패(401: 키가 틀렸거나 폐기, 만료됨)
+  4  거절(403: scope_required, static_key_required, account_pending_deletion, forbidden).
+     scope_required 는 프로젝트 키로 관리 작업을 한 경우이고, 계정 키를 console key 로 받습니다
+  5  속도 제한(429)
+  6  권한 꺼짐(console_permission_disabled, 콘솔 "AI 권한" 에서 켭니다)
+  7  서버에서 CLI 콘솔 입구가 아직 열리지 않음(404)
+  8  그 밖의 오류 응답(unknown_action, invalid_data 등)
+
+전역 설치(계정 연결과 전역 스킬)는 Gemini CLI 와 Antigravity 만 setup 으로 합니다. 그 밖은 Claude Code 는
+플러그인 마켓, ChatGPT 와 Codex 는 설치 프롬프트, Cursor 는 홈페이지의 설치 링크를 쓰세요.
 
 환경 변수:
   AIAKIV_MCP_URL             MCP 주소(기본 ${DEFAULT_MCP_URL})
   AIAKIV_CONTROL_URL         웹 콘솔 주소(기본 ${DEFAULT_CONTROL_URL})
-  AIAKIV_SKILLS_TARBALL_URL  폴더 스킬을 받는 주소(기본 ${DEFAULT_SKILLS_TARBALL_URL})
+  AIAKIV_API_KEY             console, dashboard 가 먼저 쓰는 키
+  AIAKIV_SKILLS_TARBALL_URL  폴더 스킬과 전역 스킬을 받는 주소(기본 ${DEFAULT_SKILLS_TARBALL_URL})
 
 공통: -h, --help   -v, --version`;
 class UsageError extends Error {
 }
+function parseExpiresDays(v) {
+    if (v === undefined)
+        return undefined;
+    const n = Number(v);
+    if (!Number.isInteger(n) || n < 1)
+        throw new UsageError("--expires-days 는 1 이상의 정수입니다.");
+    return n;
+}
 function parseClient(v, required) {
     if (v === undefined) {
         if (required)
@@ -43,6 +102,39 @@ function parseClient(v, required) {
     }
     return v;
 }
+/** `--client a,b --client c` 를 이름 목록으로(중복은 한 번만). */
+function clientList(values) {
+    const out = [];
+    for (const c of (values ?? []).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean)) {
+        if (!out.includes(c))
+            out.push(c);
+    }
+    return out;
+}
+/** setup 의 --client. gemini, antigravity 만 받는다. 다른 클라이언트면 갈 곳을 알린다. */
+function parseSetupClients(values) {
+    const names = clientList(values);
+    if (!names.length)
+        throw new UsageError(`--client 가 필요합니다(${GLOBAL_CLIENT_IDS.join(", ")} 중에서, 쉼표로 여럿).`);
+    for (const n of names) {
+        if (GLOBAL_CLIENT_IDS.includes(n))
+            continue;
+        if (CLIENT_IDS.includes(n) || n === "chatgpt" || n === "grok") {
+            throw new UsageError(`${SETUP_ONLY_GLOBAL_CLIENTS} (받은 값: ${n})`);
+        }
+        throw new UsageError(`--client 는 ${GLOBAL_CLIENT_IDS.join(", ")} 중에서 고릅니다(받은 값: ${n}).`);
+    }
+    return names;
+}
+/** doctor 의 --client. bind 의 넷과 antigravity. */
+function parseDoctorClients(values) {
+    return clientList(values).map((c) => {
+        if (!DOCTOR_CLIENT_IDS.includes(c)) {
+            throw new UsageError(`--client 는 ${DOCTOR_CLIENT_IDS.join(", ")} 중에서 고릅니다(받은 값: ${c}).`);
+        }
+        return c;
+    });
+}
 export async function main(argv, ctx) {
     const [cmd, ...rest] = argv;
     try {
@@ -55,11 +147,38 @@ export async function main(argv, ctx) {
             return 0;
         }
         if (cmd === "setup") {
-            // 첫 판(P2 v1)에 있던 명령. 옛 안내를 따라 친 사람에게 갈 곳을 알린다.
-            throw new UsageError("setup 명령은 없어졌습니다. 전역 설치(계정 연결과 전역 스킬)는 설치 프롬프트나 플러그인 마켓으로 하고, " +
-                "폴더 고정은 bind 를 쓰세요.");
+            // 전역 설치. Gemini CLI 와 Antigravity 만(BP-165 P6). 첫 판(P2 v1)의 setup 과는 다른 명령이다.
+            const { values, positionals } = parseArgs({
+                args: rest,
+                options: {
+                    client: { type: "string", multiple: true },
+                    "expires-days": { type: "string" },
+                    "no-browser": { type: "boolean", default: false },
+                    "no-skills": { type: "boolean", default: false },
+                    "new-key": { type: "boolean", default: false },
+                    help: { type: "boolean", short: "h" },
+                },
+                strict: true,
+                allowPositionals: true,
+            });
+            if (values.help)
+                return (ctx.out(HELP), 0);
+            if (positionals.length)
+                throw new UsageError(`setup 은 위치 인자를 받지 않습니다: ${positionals.join(" ")}`);
+            const clients = parseSetupClients(values.client);
+            return await runSetup(ctx, {
+                clients,
+                expiresDays: parseExpiresDays(values["expires-days"]),
+                noBrowser: values["no-browser"],
+                skills: !values["no-skills"],
+                newKey: values["new-key"],
+            });
         }
         if (cmd === "bind") {
+            if (rest.some((a) => /^--manage(=|$)/.test(a))) {
+                // R0(P2) 에 있던 플래그. 옛 안내를 따라 친 사람에게 갈 곳을 알린다(BP-171 §10 결정 10).
+                throw new UsageError("bind --manage 는 없어졌습니다. 관리 작업용 계정 키는 npx aiakiv console key 로 받습니다.");
+            }
             const { values } = parseArgs({
                 args: rest,
                 options: {
@@ -75,18 +194,16 @@ export async function main(argv, ctx) {
             });
             if (values.help)
                 return (ctx.out(HELP), 0);
+            if (values.client === "antigravity") {
+                throw new UsageError("Antigravity 는 앱 전체에 설정 하나라 폴더 고정이 없습니다. npx aiakiv setup --client antigravity 를 쓰세요.");
+            }
             const client = parseClient(values.client, true);
             if (!values.project?.trim())
                 throw new UsageError("--project <이름> 이 필요합니다.");
-            let expiresDays;
-            if (values["expires-days"] !== undefined) {
-                expiresDays = Number(values["expires-days"]);
-                if (!Number.isInteger(expiresDays) || expiresDays < 1) {
-                    throw new UsageError("--expires-days 는 1 이상의 정수입니다.");
-                }
-                if (client === "claude" || client === "cursor") {
-                    ctx.err(`참고: ${client} 는 키를 받지 않으므로 --expires-days 는 쓰이지 않습니다.`);
-                }
+            const expiresDays = parseExpiresDays(values["expires-days"]);
+            const oauth = client === "claude" || client === "cursor";
+            if (oauth && expiresDays !== undefined) {
+                ctx.err(`참고: ${client} 는 키를 받지 않으므로 --expires-days 는 쓰이지 않습니다.`);
             }
             return await runBind(ctx, {
                 client,
@@ -111,18 +228,78 @@ export async function main(argv, ctx) {
             });
             if (values.help)
                 return (ctx.out(HELP), 0);
-            const clients = (values.client ?? [])
-                .flatMap((c) => c.split(","))
-                .map((c) => c.trim())
-                .filter(Boolean)
-                .map((c) => parseClient(c, true));
+            const clients = parseDoctorClients(values.client);
             return await runDoctor(ctx, { clients, dir: values.dir, out: values.out, noProbe: values["no-probe"] });
         }
-        throw new UsageError(`모르는 명령입니다: ${cmd}. bind, doctor 중 하나를 쓰세요(도움말: --help).`);
+        if (cmd === "console" && rest[0] === "key") {
+            const dropped = rest.slice(1).map((a) => /^--(project|manage|team)(=|$)/.exec(a)?.[1]).find(Boolean);
+            if (dropped) {
+                throw new UsageError(`console key 는 --${dropped} 를 받지 않습니다. 계정 키는 프로젝트나 팀 없이 받습니다.`);
+            }
+            const { values, positionals } = parseArgs({
+                args: rest.slice(1),
+                options: {
+                    "expires-days": { type: "string" },
+                    dir: { type: "string" },
+                    "no-browser": { type: "boolean", default: false },
+                    help: { type: "boolean", short: "h" },
+                },
+                strict: true,
+                allowPositionals: true,
+            });
+            if (values.help)
+                return (ctx.out(HELP), 0);
+            if (positionals.length)
+                throw new UsageError(`console key 는 위치 인자를 받지 않습니다: ${positionals.join(" ")}`);
+            return await runConsoleKey(ctx, {
+                expiresDays: parseExpiresDays(values["expires-days"]),
+                dir: values.dir,
+                noBrowser: values["no-browser"],
+            });
+        }
+        if (cmd === "console") {
+            const { values, positionals } = parseArgs({
+                args: rest,
+                options: {
+                    data: { type: "string" },
+                    json: { type: "boolean", default: false },
+                    dir: { type: "string" },
+                    yes: { type: "boolean", default: false },
+                    help: { type: "boolean", short: "h" },
+                },
+                strict: true,
+                allowPositionals: true,
+            });
+            if (values.help)
+                return (ctx.out(HELP), 0);
+            if (positionals.length !== 1) {
+                throw new UsageError(positionals.length
+                    ? `액션은 하나만 줍니다(받은 값: ${positionals.join(" ")}).`
+                    : "액션 이름이 필요합니다. 목록은 npx aiakiv console describe 로 봅니다.");
+            }
+            return await runConsole(ctx, {
+                action: positionals[0], data: values.data, json: values.json, dir: values.dir, yes: values.yes,
+            });
+        }
+        if (cmd === "dashboard") {
+            const { values } = parseArgs({
+                args: rest,
+                options: {
+                    json: { type: "boolean", default: false },
+                    dir: { type: "string" },
+                    help: { type: "boolean", short: "h" },
+                },
+                strict: true,
+            });
+            if (values.help)
+                return (ctx.out(HELP), 0);
+            return await runDashboard(ctx, { json: values.json, dir: values.dir });
+        }
+        throw new UsageError(`모르는 명령입니다: ${cmd}. bind, setup, doctor, console, dashboard 중 하나를 쓰세요(도움말: --help).`);
     }
     catch (e) {
         const err = e;
-        if (e instanceof UsageError || (err.code ?? "").startsWith("ERR_PARSE_ARGS")) {
+        if (e instanceof UsageError || e instanceof ConsoleUsageError || (err.code ?? "").startsWith("ERR_PARSE_ARGS")) {
             ctx.err(err.message);
             ctx.err("도움말: npx aiakiv --help");
             return 2;