aiakiv 0.1.0 → 0.2.0

package/dist/mcpProbe.js

@@ -117,7 +117,9 @@ export async function probeSaveTarget(fetchImpl, url, key, opts = {}) {
         const t = saveTargetFromResult(result);
         if (result.isError || !t)
             return fail(call.status, "get_save_target 이 오류를 돌려줬습니다");
-        return { ok: true, team: str(t.team), project: str(t.project), binding: str(t.binding), account: str(t.account) };
+        return {
+            ok: true, team: str(t.team), project: str(t.project), binding: str(t.binding), account: str(t.account), raw: t,
+        };
     }
     catch (e) {
         const err = e;

package/dist/render.js

@@ -0,0 +1,108 @@
+// 사람이 읽는 출력(표와 목록). `--json` 이 아닐 때만 쓴다. 응답 모양을 액션마다 알지 않고, 모양을
+// 보고 그린다: 객체 배열은 표(핵심 칸 몇 개), 글자와 숫자는 "이름: 값", 나머지는 짧은 JSON.
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** 터미널 폭: 한글과 전각 문자는 두 칸. */
+export function displayWidth(s) {
+    let w = 0;
+    for (const ch of s) {
+        const c = ch.codePointAt(0) ?? 0;
+        const wide = (c >= 0x1100 && c <= 0x115f) || (c >= 0x2e80 && c <= 0xa4cf) || (c >= 0xac00 && c <= 0xd7a3) ||
+            (c >= 0xf900 && c <= 0xfaff) || (c >= 0xfe30 && c <= 0xfe4f) || (c >= 0xff00 && c <= 0xff60) ||
+            (c >= 0xffe0 && c <= 0xffe6);
+        w += wide ? 2 : 1;
+    }
+    return w;
+}
+export function padEnd(s, width) {
+    return s + " ".repeat(Math.max(0, width - displayWidth(s)));
+}
+export function truncate(s, max = 48) {
+    return [...s].length > max ? `${[...s].slice(0, max - 1).join("")}…` : s;
+}
+const isScalar = (v) => v === null || ["string", "number", "boolean"].includes(typeof v);
+/** 칸 하나를 글자로. */
+export function cellText(v, max = 48) {
+    if (v === null || v === undefined || v === "")
+        return "-";
+    if (typeof v === "boolean")
+        return v ? "예" : "아니오";
+    if (typeof v === "string" || typeof v === "number")
+        return truncate(String(v), max);
+    if (Array.isArray(v) && v.every(isScalar))
+        return v.length ? truncate(v.map((x) => String(x)).join(", "), max) : "-";
+    return truncate(JSON.stringify(v), max);
+}
+/** 표. 머리줄, 구분줄, 행들. */
+export function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(displayWidth(h), ...rows.map((r) => displayWidth(r[i] ?? ""))));
+    const line = (cells) => cells.map((c, i) => (i === cells.length - 1 ? c : padEnd(c, widths[i]))).join("  ").trimEnd();
+    return [line(headers), widths.map((w) => "-".repeat(w)).join("  "), ...rows.map(line)];
+}
+// 표에 먼저 올릴 칸 이름(있으면 이 순서로). 그 밖의 칸은 처음 나온 순서로 뒤에 붙는다.
+const PREFERRED = [
+    "name", "title", "key", "id", "link_id", "role", "status", "kind", "enabled", "is_main", "is_default",
+    "org_name", "counterparty_org_name", "email", "created_at", "ts", "action",
+];
+const MAX_COLUMNS = 6;
+export function columnsFor(rows) {
+    const seen = [];
+    for (const r of rows) {
+        for (const [k, v] of Object.entries(r)) {
+            const simple = isScalar(v) || (Array.isArray(v) && v.every(isScalar));
+            if (simple && !seen.includes(k))
+                seen.push(k);
+        }
+    }
+    const ordered = [...PREFERRED.filter((k) => seen.includes(k)), ...seen.filter((k) => !PREFERRED.includes(k))];
+    return ordered.slice(0, MAX_COLUMNS);
+}
+export function objectTable(rows) {
+    const cols = columnsFor(rows);
+    if (!cols.length)
+        return rows.map((r) => `  ${truncate(JSON.stringify(r), 120)}`);
+    return table(cols, rows.map((r) => cols.map((c) => cellText(r[c])))).map((l) => `  ${l}`);
+}
+/** 결과 객체 하나를 줄들로. */
+export function renderResult(body) {
+    if (!isObj(body))
+        return [cellText(body, 200)];
+    const lines = [];
+    for (const [k, v] of Object.entries(body)) {
+        if (Array.isArray(v) && v.length && v.every(isObj)) {
+            lines.push(`${k} (${v.length}개):`);
+            lines.push(...objectTable(v));
+        }
+        else if (Array.isArray(v) && !v.length) {
+            lines.push(`${k}: 없음`);
+        }
+        else {
+            lines.push(`${k}: ${cellText(v, isScalar(v) ? 400 : 160)}`);
+        }
+    }
+    return lines.length ? lines : ["(빈 응답)"];
+}
+/** `describe` 응답의 사람용 표: 이름, 읽기/쓰기, 권한, 위험, 접근 범위 넓힘, 인자. */
+export function renderDescribe(body) {
+    const actions = isObj(body) && isObj(body.actions) ? body.actions : null;
+    if (!actions)
+        return renderResult(body);
+    const rows = Object.entries(actions).map(([name, raw]) => {
+        const a = isObj(raw) ? raw : {};
+        const params = isObj(a.params) ? Object.keys(a.params) : [];
+        return [
+            name,
+            a.kind === "write" ? "쓰기" : a.kind === "read" ? "읽기" : cellText(a.kind),
+            cellText(a.permission),
+            Array.isArray(a.risk) && a.risk.length ? a.risk.join(",") : "-",
+            a.widens_access === true ? "넓힘" : "-",
+            params.length ? params.join(", ") : "-",
+        ];
+    });
+    const lines = table(["이름", "종류", "권한", "위험", "접근 범위", "인자"], rows);
+    lines.push("");
+    lines.push("인자 끝의 ? 는 선택입니다. 설명과 인자의 뜻은 --json 으로 봅니다.");
+    lines.push("접근 범위가 \"넓힘\" 인 쓰기는 누군가 새로 읽게 됩니다. 실행 전에 한 번 묻습니다(--yes 로 건너뜀).");
+    if (isObj(body) && typeof body.settings_url === "string")
+        lines.push(`권한 설정: ${body.settings_url}`);
+    return lines;
+}

package/dist/setup.js

@@ -0,0 +1,273 @@
+// `aiakiv setup --client gemini|antigravity[,…]` — 전역 설치(BP-165 P6, 2026-10-21 결정).
+//
+// Gemini CLI 와 Antigravity 만 한다(clients/global.ts). 흐름:
+//   1. 고른 클라이언트의 전역 설정 파일을 먼저 읽는다. 읽을 수 없으면 키를 받기 전에 멈춘다.
+//   2. 키 재사용 판정(`--new-key` 가 없을 때): 두 클라이언트의 전역 파일에서 `AiAkiv` 항목의 Bearer 키를
+//      찾아 get_save_target 을 불러 본다. 성공하고 binding 이 main 이면 그 키를 다시 쓴다(브라우저를
+//      열지 않는다). 서버 규칙상 계정 전체 키는 한 사람에게 하나만 살아 있어, 새로 받으면 앞선 키(다른 PC
+//      것 포함)가 폐기된다. 그래서 쓸 수 있는 키가 있으면 새로 받지 않는다.
+//   3. 아니면 브라우저 인계(kind=dynamic)로 키 하나를 받는다.
+//   4. 고른 클라이언트 모두의 전역 설정 파일에 같은 키를 쓴다(다른 항목은 보존, 원자적 쓰기).
+//   5. 전역 스킬(`--no-skills` 면 건너뜀). 실패해도 설정 쓰기는 성공으로 두고 칠 명령을 보여 준다.
+//   6. 사람이 할 일을 안내한다.
+//
+// 키 평문은 화면, 오류 문구 어디에도 내지 않는다(키 id 만). get_save_target 은 키 id 를 돌려주지 않으므로,
+// 새로 받을 때 키 id 와 키의 지문(sha256 앞 16자, 평문은 아니다)을 `~/.gemini/aiakiv-setup.json` 에 적어
+// 두고, 다시 쓸 때 지문이 맞으면 그 id 를 보인다.
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { GLOBAL_CLIENT_IDS, GLOBAL_CLIENT_LABEL, GLOBAL_SERVER_NAME, geminiHome, globalConfigPath, globalEntry, globalSkillsTargets, } from "./clients/global.js";
+import { ConfigError, jsonServers, readJsonObject, upsertJsonServer } from "./config/json.js";
+import { expiryText } from "./consoleKeyFile.js";
+import { classifyEntry } from "./doctor.js";
+import { readTextIfExists, writeFileAtomic } from "./fsutil.js";
+import { exchangeCode, handoffUrl, HANDOFF_TIMEOUT_MS, newState, scopeList, startLoopback, supersededNotice, } from "./handoff.js";
+import { probeSaveTarget } from "./mcpProbe.js";
+import { downloadSkillPack, SKILL_NAMES, SKILLS_REPO, skillsGlobalManualCommand, writeSkillsTo } from "./skills.js";
+import { canonicalMcpUrl, controlBase } from "./urls.js";
+import { VERSION } from "./version.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** 새로 받은 키의 기록(평문 없음). `~/.gemini/aiakiv-setup.json`. */
+export const SETUP_RECORD = "aiakiv-setup.json";
+export function keyFingerprint(key) {
+    return createHash("sha256").update(key, "utf8").digest("hex").slice(0, 16);
+}
+export function setupRecordPath(ctx) {
+    return join(geminiHome(ctx), SETUP_RECORD);
+}
+function readSetupRecord(ctx) {
+    try {
+        const text = readTextIfExists(setupRecordPath(ctx));
+        if (text === null)
+            return null;
+        const v = JSON.parse(text);
+        if (!isObj(v) || typeof v.key_id !== "string" || typeof v.key_fingerprint !== "string")
+            return null;
+        return v;
+    }
+    catch {
+        return null;
+    }
+}
+// 키 순서와 상관없이 같은 항목인가(같으면 파일을 다시 쓰지 않는다).
+function canonical(v) {
+    if (Array.isArray(v))
+        return v.map(canonical);
+    if (isObj(v))
+        return Object.fromEntries(Object.keys(v).sort().map((k) => [k, canonical(v[k])]));
+    return v;
+}
+const sameEntry = (a, b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+/** 고른 클라이언트의 전역 파일을 읽는다. 읽을 수 없거나 mcpServers 가 객체가 아니면 ConfigError(아무것도 쓰지 않는다). */
+function readTargets(ctx, clients) {
+    return clients.map((client) => {
+        const file = globalConfigPath(ctx, client);
+        const doc = readJsonObject(file);
+        if (doc && doc.mcpServers !== undefined && !isObj(doc.mcpServers)) {
+            throw new ConfigError(`${file} 의 mcpServers 가 객체가 아닙니다. 파일은 바꾸지 않았습니다.`);
+        }
+        return { client, file, existing: jsonServers(doc)[GLOBAL_SERVER_NAME] };
+    });
+}
+/** 두 클라이언트의 전역 파일에서 `AiAkiv` 항목의 Bearer 키를 찾아 get_save_target 으로 확인한다.
+ * 성공하고 binding 이 main 인 첫 키를 돌려준다. 못 쓰는 키는 이유를 한 줄씩 알린다(평문 없이). */
+async function findReusableKey(ctx, url) {
+    const tried = new Set();
+    for (const client of GLOBAL_CLIENT_IDS) {
+        const file = globalConfigPath(ctx, client);
+        let raw;
+        try {
+            raw = jsonServers(readJsonObject(file))[GLOBAL_SERVER_NAME];
+        }
+        catch (e) {
+            ctx.err(`참고: ${e.message}`);
+            continue;
+        }
+        if (!raw)
+            continue;
+        const e = classifyEntry({ client, scope: "전역", file, name: GLOBAL_SERVER_NAME }, raw, ctx.env);
+        if (e.auth !== "apikey" || !e.key || tried.has(e.key))
+            continue;
+        tried.add(e.key);
+        const p = await probeSaveTarget(ctx.fetch, url, e.key, { version: VERSION });
+        if (p.ok && p.binding === "main")
+            return { key: e.key, from: file };
+        const why = p.ok
+            ? `binding 이 ${p.binding ?? "?"} 라 계정 전체 키가 아닙니다`
+            : `확인 실패${p.status ? `(${p.status})` : ""}: ${p.reason}`;
+        ctx.out(`${file} 의 ${GLOBAL_SERVER_NAME} 키는 다시 쓸 수 없습니다(${why}).`);
+    }
+    return null;
+}
+export async function runSetup(ctx, opts) {
+    try {
+        return await setup(ctx, opts);
+    }
+    catch (e) {
+        ctx.err(e.message);
+        return 1;
+    }
+}
+async function newKeyByHandoff(ctx, opts, url) {
+    const control = controlBase(ctx.env);
+    const timeoutMs = opts.timeoutMs ?? HANDOFF_TIMEOUT_MS;
+    const state = newState();
+    const lb = await startLoopback(state, timeoutMs);
+    const hurl = handoffUrl(control, {
+        kind: "dynamic", port: lb.port, state, client: opts.clients.join(","), expiresDays: opts.expiresDays,
+    });
+    ctx.out("웹 콘솔에서 계정 전체 기억 키를 이 PC 로 받습니다. 이 키는 Main(저장 대상)을 따라갑니다.");
+    ctx.out("계정 전체 키는 한 사람에게 하나만 살아 있어, 새로 받으면 앞선 키(다른 PC 에 넣은 것 포함)는 폐기됩니다.");
+    ctx.out("브라우저에서 로그인하고 확인 버튼을 누르세요. 브라우저가 열리지 않으면 이 주소를 직접 여세요:");
+    ctx.out(`  ${hurl}`);
+    if (!opts.noBrowser) {
+        const opened = await ctx.openUrl(hurl);
+        if (!opened)
+            ctx.err("브라우저를 열지 못했습니다. 위 주소를 직접 여세요.");
+    }
+    ctx.out(`기다리는 중(최대 ${Math.round(timeoutMs / 60_000)}분, 127.0.0.1:${lb.port})...`);
+    let code;
+    try {
+        code = await lb.code;
+    }
+    catch (e) {
+        lb.close();
+        ctx.err(e.message);
+        ctx.err("명령을 다시 실행하세요.");
+        return null;
+    }
+    // 응답 kind 가 dynamic 이 아니면(서버가 옛 판) 여기서 HandoffError 로 끝난다. 받은 평문은 쓰지 않는다.
+    const res = await exchangeCode(ctx.fetch, control, { code, state, port: lb.port }, "dynamic");
+    const scopes = scopeList(res.scopes).join(",");
+    const expiresAt = typeof res.expires_at === "string" && res.expires_at ? res.expires_at : null;
+    ctx.out();
+    ctx.out(`계정 전체 키를 받았습니다. 키 id ${res.key_id}, 스코프 ${scopes || "?"}, 만료 ${expiryText(expiresAt)}.`);
+    const sup = supersededNotice(res.superseded, "dynamic");
+    if (sup)
+        ctx.out(sup);
+    if (typeof res.mcp_url === "string" && res.mcp_url && res.mcp_url !== url) {
+        ctx.err(`참고: 서버가 알려 준 MCP 주소(${res.mcp_url})와 설정에 쓰는 주소(${url})가 다릅니다. ` +
+            "AIAKIV_MCP_URL 이 맞는지 확인하세요.");
+    }
+    try {
+        const rec = {
+            key_id: res.key_id,
+            key_fingerprint: keyFingerprint(res.plaintext),
+            scopes,
+            expires_at: expiresAt,
+            issued_at: new Date().toISOString(),
+        };
+        writeFileAtomic(setupRecordPath(ctx), `${JSON.stringify(rec, null, 2)}\n`);
+    }
+    catch (e) {
+        // 기록은 다시 쓸 때 키 id 를 보이는 데만 쓴다. 못 써도 설치는 계속한다.
+        ctx.err(`참고: ${setupRecordPath(ctx)} 에 키 id 를 적지 못했습니다(${e.message}).`);
+    }
+    return { key: res.plaintext, keyId: res.key_id, reused: false };
+}
+async function setup(ctx, opts) {
+    const url = canonicalMcpUrl(ctx.env);
+    const targets = readTargets(ctx, opts.clients);
+    ctx.out(`전역 설치: ${opts.clients.map((c) => GLOBAL_CLIENT_LABEL[c]).join(", ")}`);
+    let got = null;
+    if (!opts.newKey) {
+        const r = await findReusableKey(ctx, url);
+        if (r) {
+            const rec = readSetupRecord(ctx);
+            const keyId = rec && rec.key_fingerprint === keyFingerprint(r.key) ? rec.key_id : undefined;
+            got = { key: r.key, keyId, reused: true };
+            if (opts.expiresDays !== undefined) {
+                ctx.err("참고: 받아 둔 키를 다시 쓰므로 --expires-days 는 쓰이지 않았습니다. 새 키를 받으려면 --new-key 를 더하세요.");
+            }
+        }
+    }
+    if (!got) {
+        got = await newKeyByHandoff(ctx, opts, url);
+        if (!got)
+            return 1;
+    }
+    let failed = false;
+    const keyFiles = [];
+    for (const t of targets) {
+        const entry = globalEntry(t.client, url, got.key);
+        const label = GLOBAL_CLIENT_LABEL[t.client];
+        if (t.existing && sameEntry(t.existing, entry)) {
+            ctx.out(`그대로 둡니다: ${t.file} (${label}, 같은 키와 주소가 이미 있습니다)`);
+            keyFiles.push(t.file);
+            continue;
+        }
+        try {
+            const r = upsertJsonServer(t.file, GLOBAL_SERVER_NAME, entry, { secret: true });
+            keyFiles.push(t.file);
+            ctx.out(`${r.replaced ? "바꿨습니다" : "더했습니다"}: ${t.file} (${label})`);
+            ctx.out(`  서버 이름 ${GLOBAL_SERVER_NAME}`);
+            ctx.out(`  주소 ${url}`);
+            if (r.backup) {
+                ctx.out(`  참고: 원래 파일에 주석이나 끝 쉼표가 있어 표준 JSON 으로 다시 썼습니다. 원본은 ${r.backup} 에 남겼습니다. ` +
+                    "원본에는 예전 키가 들어 있을 수 있으니 확인한 뒤 지우세요.");
+            }
+        }
+        catch (e) {
+            failed = true;
+            ctx.err(`${t.file} 에 쓰지 못했습니다(${e.message}).`);
+        }
+    }
+    if (got.reused) {
+        ctx.out(`이미 받아 둔 계정 전체 키를 다시 썼습니다(키 id ${got.keyId ?? "모름, 이 PC 의 setup 기록에 없습니다"}).`);
+    }
+    if (opts.skills !== false)
+        await installGlobalSkills(ctx, opts.clients);
+    else
+        ctx.out("전역 스킬: --no-skills 라 건너뜁니다.");
+    ctx.out("다음 할 일(사람):");
+    if (opts.clients.includes("gemini")) {
+        ctx.out(`  - Gemini CLI: gemini 를 실행한 뒤 /mcp 에서 ${GLOBAL_SERVER_NAME} 가 연결됐는지 보고, ` +
+            "\"저장 대상 확인해 줘\" 라고 해서 binding 이 main 인지 확인하세요.");
+    }
+    if (opts.clients.includes("antigravity")) {
+        ctx.out(`  - Antigravity: Agent 설정의 MCP Servers 에서 ${GLOBAL_SERVER_NAME} 가 보이는지 확인하세요. ` +
+            "앱이 켜져 있었다면 설정 파일을 바꿨으니 앱을 다시 시작하세요.");
+    }
+    ctx.out(`  - 확인: npx aiakiv doctor --client ${opts.clients.join(",")}`);
+    // 홈 폴더 파일이라 .gitignore 로 빼 줄 수 없다. 마지막 줄로 알린다.
+    if (keyFiles.length) {
+        ctx.err(`주의: 키 평문이 ${keyFiles.join(", ")} 에 있습니다. ` +
+            `${keyFiles.length > 1 ? "이 파일들을" : "이 파일을"} 공유하거나 커밋하지 마세요.`);
+    }
+    return failed ? 1 : 0;
+}
+function manualSkillsLine(t) {
+    return t.skillsAgent
+        ? `직접 실행하세요: ${skillsGlobalManualCommand(t.skillsAgent)}`
+        : `https://github.com/${SKILLS_REPO} 의 aiakiv/skills/ 아래 스킬 폴더들을 ${t.dir} 에 폴더째 복사하세요.`;
+}
+/** 전역 스킬 단계. 실패하면 false 와 함께 사람이 할 일을 보여 준다(예외를 내지 않는다). */
+export async function installGlobalSkills(ctx, clients) {
+    const targets = clients.flatMap((c) => globalSkillsTargets(ctx, c).map((t) => ({ client: c, ...t })));
+    let pack;
+    try {
+        pack = await downloadSkillPack(ctx);
+    }
+    catch (e) {
+        ctx.err(`전역 스킬을 받지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
+        for (const t of targets)
+            ctx.err(`  ${GLOBAL_CLIENT_LABEL[t.client]}(${t.dir}): ${manualSkillsLine(t)}`);
+        return false;
+    }
+    let ok = true;
+    for (const t of targets) {
+        try {
+            const names = writeSkillsTo(t.dir, pack);
+            ctx.out(`전역 스킬 ${names.length}개: ${t.dir} (${GLOBAL_CLIENT_LABEL[t.client]}, 판 ${pack.version ?? "모름"})`);
+            const missing = SKILL_NAMES.filter((n) => !names.includes(n));
+            if (missing.length)
+                ctx.err(`  참고: 받은 스킬에 ${missing.join(", ")} 이 없습니다.`);
+        }
+        catch (e) {
+            ok = false;
+            ctx.err(`전역 스킬을 ${t.dir} 에 쓰지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
+            ctx.err(`  ${manualSkillsLine(t)}`);
+        }
+    }
+    return ok;
+}

package/dist/skills.js

@@ -1,4 +1,4 @@
-// 폴더 스킬. 웹 콘솔 "폴더 ZIP 받기" 와 같은 자리에 스킬 일곱 개를 넣는다
+// 폴더 스킬. 웹 콘솔 "폴더 ZIP 받기" 와 같은 자리에 스킬 여덟 개를 넣는다
 // (정본은 k2g-console-web `src/lib/folderBundle.ts` 의 SKILL_DIR 와 assertSkillPath).
 //
 // 받는 곳은 공개 저장소 AiAkiv/aiakiv-plugins 의 tar.gz(GitHub codeload). 새 의존성 없이 Node 내장
@@ -27,6 +27,8 @@ export const SKILL_NAMES = [
     "aiakiv-cards",
     "aiakiv-console",
     "aiakiv-contents",
+    // BP-171 P3 가 만들고 P5 가 함께 발행한다. 그 전의 설치본에는 없어 "받은 스킬에 … 이 없습니다" 가 나온다.
+    "aiakiv-dashboard",
 ];
 /** 클라이언트별 폴더 스킬 자리(폴더 기준 상대 경로). */
 export const FOLDER_SKILLS_DIR = {
@@ -47,6 +49,12 @@ export const SKILLS_AGENT = {
 export function skillsManualCommand(agent) {
     return `npx -y skills add ${SKILLS_REPO} -a ${agent} -s '*' -y`;
 }
+/** setup(전역 설치)에서 받기에 실패했을 때 칠 명령. 전역이라 `-g` 를 붙인다. `agent` 는 Skills CLI 의
+ * 에이전트 이름(Skills CLI 1.5.18 에서 gemini-cli 의 전역 자리는 `~/.gemini/skills`, antigravity-cli 는
+ * `~/.gemini/antigravity-cli/skills` 로 setup 이 쓰는 자리와 같다). */
+export function skillsGlobalManualCommand(agent) {
+    return `npx -y skills add ${SKILLS_REPO} -a ${agent} -s '*' -g -y`;
+}
 // 내려받는 크기 한도(지금 저장소는 압축 50KB 안팎).
 const MAX_GZ_BYTES = 20 * 1024 * 1024;
 const MAX_TAR_BYTES = 64 * 1024 * 1024;
@@ -196,7 +204,11 @@ function removeExisting(p) {
 /** `<dir>/<rel>/<스킬>/` 에 쓴다. 같은 이름 스킬 폴더는 통째로 바꾸고, 그 밖의 파일은 건드리지 않는다.
  * 스킬마다 임시 폴더에 다 쓴 뒤 이름을 바꾸므로, 쓰다 멈춰도 예전 스킬이 반쯤 지워지지 않는다. */
 export function writeFolderSkills(dir, rel, pack) {
-    const root = resolve(dir, ...rel.split("/"));
+    return writeSkillsTo(resolve(dir, ...rel.split("/")), pack);
+}
+/** 스킬 자리 `<root>/<스킬>/` 에 쓴다(writeFolderSkills 와 같은 규칙). setup 은 홈 폴더 아래의 전역 자리를 준다. */
+export function writeSkillsTo(rootDir, pack) {
+    const root = resolve(rootDir);
     mkdirSync(root, { recursive: true });
     const written = [];
     for (const [name, files] of pack.skills) {

package/dist/version.js

@@ -1,2 +1,2 @@
 // package.json 의 version 과 같아야 한다(tests/cli.test.mjs 가 확인).
-export const VERSION = "0.1.0";
+export const VERSION = "0.2.0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiakiv",
-  "version": "0.1.0",
-  "description": "AiAkiv CLI: pin a folder to an AiAkiv project (connection, folder skills, settings) and check it.",
+  "version": "0.2.0",
+  "description": "AiAkiv CLI: pin a folder to an AiAkiv project (connection, folder skills, settings), check it, and run console actions and a dashboard from the shell.",
   "license": "MIT",
   "type": "module",
   "bin": {