kasaframe 0.1.4 → 0.1.6

package/packages/cli/src/commands/fonts.ts

@@ -0,0 +1,118 @@
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { type FontPair, fontGroups, fontPairs } from "@kasaframe/themes/fonts";
+import { type Command, parseFlags } from "../command.ts";
+import { checkFonts, fontCacheDir, fontSheet, noticeSection, type PairReport, replaceNotice } from "../fonts.ts";
+
+const cmd: Command = {
+  summary: "글꼴 짝 검사·견본 격자 — 주소·판·라이선스 글·한글 덮음·굵기, 크롬으로 찍어 투명·두부·떨어짐",
+  usage: `kf fonts list [--group <무리>]
+kf fonts check [--group <무리>[,…]] [--id <짝>[,…]] [--json] [--no-render] [--offline]
+kf fonts sheet [--group <무리>[,…]] [--id <짝>[,…]] [--out 파일.png] [--share]
+kf fonts notice [--write]
+
+  짝 목록은 packages/themes/kit/fonts.json(무리 core)과 kit/fonts/<무리>.json 을 합친 것.
+  check 는 짝마다
+    - 칸: hangul(full|ks2350)·face 마다 license·source, 스택 첫 글꼴의 face, 모든 스택이 Pretendard Variable 로 끝남
+    - 주소: 파일·라이선스 글이 200, 판 박힘(jsdelivr gh@커밋|태그·npm@x.y.z — @main·@latest·@5 는 안 된다)
+    - 라이선스 글: OFL-1.1·Apache-2.0 은 글에 그 문구가 있는지. 목록 밖 이름은 사람이 읽을 것으로 남긴다
+    - 파일: 한글 음절 수(11,172 = full, KS X 1001 2,350 다 = ks2350, 그 아래는 탈락)와 적은 hangul 이 맞는지,
+      적은 굵기 범위가 파일(wght 축·usWeightClass)과 맞는지, 제목 굵기 단이 있는지(없으면 가짜 굵기)
+    - 크롬: 스택마다 한글·라틴·숫자 견본 한 줄을 찍어 투명·두부·시스템 글꼴로 떨어짐·예상과 다른 face 를 잡는다
+  받은 파일은 ${fontCacheDir()}/files 에 두고 다음부터는 주소가 살았는지만 묻는다. 문제가 있는 짝이 있으면 종료 1.
+  --json      { pairs: [{ id, group, ok, hangul, syllables, boldest, licenses, problems, notes }], summary }
+  --no-render 크롬 없이(파일·주소만)
+  --offline   주소를 묻지 않고 캐시만(라이선스 글 대조도 건너뛴다)
+  sheet 는 짝마다 제목·본문·고정폭 견본 칸을 격자 한 장으로 — 기본 ${fontCacheDir()}/sheet[-<무리>].png.
+  --share 면 kasaterm 공유 폴더 kasaframe-글꼴 로 옮긴다.
+  notice 는 모든 무리를 합친 목록으로 NOTICE 의 글꼴 절(글꼴 이름 · 라이선스 · 라이선스 글)을 찍는다. --write 면 레포 NOTICE 에
+  그 절을 갈아 끼운다 — 무리 파일을 고친 뒤 한 번.`,
+  async run(argv) {
+    const [sub, ...rest] = argv;
+    const { opts } = parseFlags(rest);
+    const list = pick(opts);
+    if (!list) return 2;
+    if (sub === "list" || !sub) {
+      for (const { group, pair } of list) console.log(`${group.padEnd(10)} ${pair.id.padEnd(26)} ${String(pair.hangul ?? "?").padEnd(7)} ${pair.tags.join(",").padEnd(30)} ${pair.name}`);
+      console.log(`짝 ${list.length}`);
+      return 0;
+    }
+    if (sub === "check") {
+      const reports = await checkFonts(list, { offline: !!opts.offline, render: !opts["no-render"], log: (l) => console.error(l) });
+      const summary = summarize(reports);
+      if (opts.json) console.log(JSON.stringify({ pairs: reports, summary }, null, 1));
+      else print(reports, summary);
+      return reports.every((r) => r.ok) ? 0 : 1;
+    }
+    if (sub === "notice") {
+      const section = noticeSection(fontPairs());
+      if (!opts.write) {
+        process.stdout.write(section);
+        return 0;
+      }
+      const file = fileURLToPath(new URL("../../../../NOTICE", import.meta.url));
+      writeFileSync(file, replaceNotice(readFileSync(file, "utf8"), section));
+      console.log(file);
+      return 0;
+    }
+    if (sub === "sheet") {
+      const groups = typeof opts.group === "string" ? opts.group.replace(/,/g, "+") : "";
+      const out = resolve(typeof opts.out === "string" ? opts.out : join(fontCacheDir(), `sheet${groups ? `-${groups}` : ""}.png`));
+      await fontSheet(list, out, { log: (l) => console.error(l) });
+      console.log(out);
+      if (opts.share) {
+        const r = spawnSync("kasaterm-cli", ["share", "new", "kasaframe-글꼴"], { encoding: "utf8" });
+        let dir = r.status === 0 ? (r.stdout.trim().split("\n").pop() ?? "") : "";
+        if (!dir || !existsSync(dir)) {
+          dir = join(homedir(), "Desktop", "kasaframe-글꼴");
+          mkdirSync(dir, { recursive: true });
+        }
+        copyFileSync(out, join(dir, basename(out)));
+        console.log(`공유 폴더 ${dir}`);
+      }
+      return 0;
+    }
+    console.error(`kf fonts: 모르는 하위 명령 ${sub} — list·check·sheet·notice`);
+    return 2;
+  },
+};
+
+function pick(opts: Record<string, string | boolean | undefined>): { group: string; pair: FontPair }[] | null {
+  const groups = fontGroups();
+  const want = typeof opts.group === "string" ? opts.group.split(",") : null;
+  const unknown = want?.filter((g) => !groups.some((x) => x.group === g));
+  if (unknown?.length) {
+    console.error(`kf fonts: 무리 ${unknown.join(",")} 가 없다 — 있는 무리: ${groups.map((g) => g.group).join(" ")}`);
+    return null;
+  }
+  const ids = typeof opts.id === "string" ? new Set(opts.id.split(",")) : null;
+  const list = groups.filter((g) => !want || want.includes(g.group)).flatMap((g) => g.pairs.map((pair) => ({ group: g.group, pair }))).filter(({ pair }) => !ids || ids.has(pair.id));
+  if (ids && list.length < ids.size) console.error(`kf fonts: 없는 짝 — ${[...ids].filter((i) => !list.some((x) => x.pair.id === i)).join(",")}`);
+  return list;
+}
+
+const tally = (xs: string[]) => Object.fromEntries([...new Set(xs)].sort().map((x) => [x, xs.filter((y) => y === x).length]));
+
+function summarize(reports: PairReport[]) {
+  return {
+    pairs: reports.length,
+    ok: reports.filter((r) => r.ok).length,
+    hangul: tally(reports.map((r) => r.hangul ?? "?")),
+    licenses: tally(reports.flatMap((r) => r.licenses)),
+  };
+}
+
+function print(reports: PairReport[], s: ReturnType<typeof summarize>): void {
+  for (const r of reports) {
+    console.log(`${r.ok ? "ok  " : "문제"} ${r.group.padEnd(10)} ${r.id.padEnd(26)} 한글 ${r.hangul ?? "?"}(${r.syllables ?? "?"}) · 굵은 단 ${r.boldest ?? "?"} · ${r.licenses.join(",")}`);
+    for (const p of r.problems) console.log(`       ! ${p}`);
+    for (const n of r.notes) console.log(`       · ${n}`);
+  }
+  const fmt = (o: Record<string, number>) => Object.entries(o).map(([k, v]) => `${k} ${v}`).join(" · ");
+  console.log(`\n짝 ${s.pairs} — 통과 ${s.ok} · 문제 ${s.pairs - s.ok} | 한글 ${fmt(s.hangul)} | 라이선스(짝 기준) ${fmt(s.licenses)}`);
+}
+
+export default cmd;

package/packages/cli/src/commands/make.ts

@@ -103,6 +103,7 @@ kf make --answer <폴더> --image <값> --video <값> …   Claude Code 모드
   --video-provider  영상 공급자를 못 박는다(예: h3-pod — KF_H3_URL·KF_H3_STEPS 필요). 기본은 KF_VIDEO_PROVIDER, 없으면 생성 담당 기본
   --fix           검사가 떨어졌을 때 고치기 횟수(기본 2)
   --captions on|off|fit  화면 자막(fit 은 장면을 자막 띠 위로 줄여 올린다) — 새로 만들 땐 kf.json 에 적고, --finish 에선 그 판만 덮는다(다시 만들지 않고 켜고 끄기). srt·vtt 는 둘 다 낸다
+  --sfx on|off    효과음(기본 켬 — 테마가 고른 결로 장면 움직임 자리에 곡 아래 작게) — 새로 만들 땐 off 를 kf.json 에 sfx: false 로 적고, --finish 에선 그 판만 덮는다
   --suffix [글]   --finish 결과 이름 뒤에 붙인다(값 없이면 -자막 · -자막없음) — 원본 video.mp4 를 덮지 않고 둘 다 남긴다
   --no-gen        생성 모델을 부르지 않는다 — 묻지 않고 그림·영상 모델은 빼고, Blender 가 없으면 three 로 대신한다
 
@@ -171,6 +172,11 @@ async function make(argv: string[], at: Track): Promise<number> {
     return 2;
   }
   const suffix = str("suffix") ?? (opts.suffix ? (captions === "off" ? "-자막없음" : "-자막") : "");
+  const sfx = str("sfx");
+  if (sfx !== undefined && sfx !== "on" && sfx !== "off") {
+    console.error(`kf make: --sfx 는 on·off — ${sfx}`);
+    return 2;
+  }
 
   if (opts.answer) {
     at.quiet = true;
@@ -192,7 +198,7 @@ async function make(argv: string[], at: Track): Promise<number> {
       const narrate = sayChanged(dir, ids) ? [] : ["--no-narrate"];
       const d = await relay(["direct", dir, "--scenes", ids.join(","), ...narrate, "--no-check", ...pick]);
       if (d !== 0) return d;
-      return finish(dir, { model: "direct", vision, fixes: 0, scenes: ids });
+      return finish(dir, { model: "direct", vision, fixes: 0, scenes: ids, sfx });
     }
     // 다시 쓰기는 그 일을 만든 모델로 — 기본 모델로 몰래 바꾸지 않는다
     const own = str("model") ?? readPlan(dir).model;
@@ -208,7 +214,7 @@ async function make(argv: string[], at: Track): Promise<number> {
     }
     writeFileSync(join(dir, "MAKE.md"), projectBrief(dir));
     await writeScenes(dir, own, ids);
-    return finish(dir, { model: own, vision, fixes, scenes: ids });
+    return finish(dir, { model: own, vision, fixes, scenes: ids, sfx });
   }
   if (opts.finish) {
     const dir = resolve(typeof opts.finish === "string" ? opts.finish : (args[0] ?? "."));
@@ -220,7 +226,7 @@ async function make(argv: string[], at: Track): Promise<number> {
     if (studio) console.log(`작업실: ${studio.url}`);
     await studio?.send({ phase: "render" });
     const scenes = str("scenes")?.split(",").filter(Boolean);
-    const code = await finish(dir, { model, vision, fixes, gen: opts["no-gen"] ? undefined : gen, captions, suffix, ...(scenes?.length ? { scenes } : {}) });
+    const code = await finish(dir, { model, vision, fixes, gen: opts["no-gen"] ? undefined : gen, captions, suffix, sfx, ...(scenes?.length ? { scenes } : {}) });
     await unmirror?.();
     await studio?.send({ done: true, ok: code === 0 });
     return code;
@@ -352,6 +358,10 @@ async function make(argv: string[], at: Track): Promise<number> {
     writeJson(kfPath, { ...JSON.parse(readFileSync(kfPath, "utf8")), captions });
     plan.captions = captionMode(captions);
   }
+  if (sfx === "off") {
+    const kfPath = join(dir, "kf.json");
+    writeJson(kfPath, { ...JSON.parse(readFileSync(kfPath, "utf8")), sfx: false });
+  }
   if (!str("purpose") && !series) {
     plan.confidence = chosen?.p ?? det.confidence;
     plan.alternatives = det.ranked.filter((r) => r.purpose !== purpose).slice(0, 2).map((r) => ({ purpose: r.purpose, p: r.p }));
@@ -901,7 +911,7 @@ async function seamStills(dir: string, only?: string[]): Promise<void> {
 
 // captions 를 주면 그 판만 화면 자막을 켜고 끈다(kf.json 은 그대로) — 굽기·검사·자막 트랙이 같은 값을 본다
 // scenes 를 주면 그 장면 둘레(그 장면 + 붙은 이음매)만 — 이음 화면·검사를 그 구간에서. 굽기는 kf render 가 바뀐 조각만 다시 찍는다
-async function finish(dir: string, o: { model: string; vision: string; fixes: number; gen?: GenOpts; captions?: "on" | "off" | "fit"; suffix?: string; scenes?: string[] }): Promise<number> {
+async function finish(dir: string, o: { model: string; vision: string; fixes: number; gen?: GenOpts; captions?: "on" | "off" | "fit"; suffix?: string; scenes?: string[]; sfx?: string }): Promise<number> {
   if (!existsSync(join(dir, "kf.json"))) {
     console.error(`kf make: ${dir} 에 kf.json 이 없다`);
     return 2;
@@ -921,7 +931,7 @@ async function finish(dir: string, o: { model: string; vision: string; fixes: nu
     if (round > 0) await seamStills(dir, touched);
     // 굽기와 검사 사이에 잠금을 놓으면 기다리던 남의 긴 렌더가 끼어든다 — 둘을 한 번에 쥐고 자식은 잠금 없이
     const release = await acquireRenderLock(dir, 3600);
-    const r = await relay(["render", dir, "--out", out, "--tabs", "2", "--no-lock", ...capFlag]);
+    const r = await relay(["render", dir, "--out", out, "--tabs", "2", "--no-lock", ...capFlag, ...(o.sfx ? ["--sfx", o.sfx] : [])]);
     if (r !== 0) {
       release();
       console.error("kf make: 렌더가 실패했다");

package/packages/cli/src/commands/render.ts

@@ -8,7 +8,8 @@ import { acquireRenderLock } from "../lock.ts";
 import { blurOpts, captureBlurred, projectBlur, rgbaToPng } from "../blur.ts";
 import { outPath } from "../out.ts";
 import { cachedSegment, collectEvents, type KeyOpts, type MotionEvent, pruneSegments, renderSegments, sceneKeys, sceneSpans, type SegmentReport, type SegmentWork, variantOf } from "../segments.ts";
-import { mixAudio, mixSettings } from "../mix.ts";
+import { mixAudio, mixSettings, SFX_AUDIO, type SfxMix } from "../mix.ts";
+import { cuesOf, loadBank, placeSfx, projectDrops, sfxSettings } from "../sfx.ts";
 
 const MAX_TABS = 3;
 
@@ -61,7 +62,7 @@ function withSuffix(p: string, suffix: string): string {
 
 const cmd: Command = {
   summary: "MP4(또는 ProRes·PNG 묶음)로 굽기 — 탭 병렬, 곡 얹기, 잠금",
-  usage: `kf render <폴더> [--out x.mp4] [--scenes a,b] [--from 초 --to 초] [--tabs 3] [--prores | --png] [--music 곡 | --no-music] [--captions on|off|fit [--suffix]]
+  usage: `kf render <폴더> [--out x.mp4] [--scenes a,b] [--from 초 --to 초] [--tabs 3] [--prores | --png] [--music 곡 | --no-music] [--sfx on|off] [--captions on|off|fit [--suffix]]
   --out       기본 <폴더>/out/render.mp4 (--prores 면 .mov, --png 면 폴더)
   seek 모드는 장면 조각으로 굽는다 — 장면마다 out/segments/<장면>-<해시>.mp4(해시: 그 장면이 실제로 불러온 모듈·kf.json 그 장면 칸·
               자산·자막 줄·굽기 설정, 이음매는 앞뒤 장면까지). 해시가 같은 조각은 다시 찍지 않고 이어 붙인 뒤 곡·목소리를 전체로 얹는다
@@ -71,6 +72,8 @@ const cmd: Command = {
   --tabs      크롬 탭 수(최대 ${MAX_TABS}). seek 모드는 구간을 나눠 찍고, step 모드는 탭마다 구간 앞까지 빨리 돌린 뒤 찍는다
   --music     기본은 페이지 meta.music(kf.json 의 music). 곡은 beats.json 의 from 초부터 얹는다
   --music-from 곡에서 시작할 초를 직접 준다(--music 으로 다른 곡을 줄 때)
+  --sfx on|off 효과음(기본 켬) — 장면 움직임이 남긴 소리 자리(__kf.events 의 sfx)와 곡의 드롭에 테마가 고른 결(theme.json sfx)의 소리를
+              곡 아래로 작게 깐다. off 면 이 판만 끄고(효과음 이전과 같은 소리), on 이면 kf.json sfx: false 도 이 판만 켠다. --no-music 이면 없다
   --crf       H.264 화질(기본 16, 낮을수록 좋다)
   --motion-blur N  한 프레임을 하위 프레임 N 장(예 8)으로 찍어 평균 — 빠른 것만 번진다. 3D 전환은 같은 평균으로 피사계 심도도. seek 모드만, N 배 느리다.
               안 주면 kf.json 의 render.motionBlur(쇼츠·홍보 틀은 켜 둔다), 0 이면 끈다
@@ -91,6 +94,8 @@ const cmd: Command = {
     const format: VideoFormat | "png" = opts.png ? "png" : opts.prores ? "prores" : "h264";
     const ext = format === "prores" ? ".mov" : format === "png" ? "" : ".mp4";
     const captions = opts.captions === undefined ? undefined : String(opts.captions);
+    const sfxFlag = opts.sfx === undefined ? undefined : String(opts.sfx);
+    if (sfxFlag !== undefined && sfxFlag !== "on" && sfxFlag !== "off") throw new Error(`--sfx 는 on·off: ${sfxFlag}`);
     if (captions !== undefined && captions !== "on" && captions !== "off" && captions !== "fit") throw new Error(`--captions 는 on·off·fit: ${captions}`);
     const suffix = typeof opts.suffix === "string" ? opts.suffix : opts.suffix ? (captions === "off" ? "-자막없음" : "-자막") : "";
     const out = withSuffix(outPath(dir, opts.out, format === "png" ? "frames/x" : `render${ext}`).replace(/\/x$/, ""), suffix);
@@ -139,6 +144,8 @@ const cmd: Command = {
         console.error(`  ${done}/${todo} (${((done / Math.max(1, todo)) * 100).toFixed(0)}%) ${(done / sec).toFixed(1)} 장/초`);
       }, 5000);
 
+      let sfx: SfxMix | undefined;
+      let sfxCues = 0;
       let segFiles: string[] = [];
       let events: MotionEvent[] = [];
       let segments: { rendered: string[]; reused: string[] } | undefined;
@@ -209,13 +216,24 @@ const cmd: Command = {
       if (format !== "png") {
         const list = join(tmp, "list.txt");
         writeFileSync(list, segFiles.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n") + "\n");
-        // kf.json 에 audio(섞기 값)가 있으면 내레이션·곡을 섞은 소리를 얹는다(덕킹·끝 페이드·LUFS) — 없으면 곡만
-        const mix = opts["no-music"] ? null : mixSettings(resolve(dir));
-        const mixed = mix && (mix.voice || music)
-          ? await mixAudio({ voice: mix.voice, music, musicFrom: songFrom }, { audio: mix.audio, from: startF / fps, dur: frames / fps, total: meta.duration, out: join(tmp, "mix.wav") })
+        // 효과음 — 찍는 동안 페이지가 남긴 소리 자리를 밀도대로 걸러 깐다. 끄면(--sfx off·kf.json sfx: false) 아래는 효과음 이전과 같은 길
+        const settings = opts["no-music"] ? null : sfxSettings(resolve(dir), sfxFlag);
+        if (settings) {
+          const bank = loadBank();
+          if (!bank.sets.includes(settings.set)) throw new Error(`효과음 결 "${settings.set}" 이 없다 — 있는 결: ${bank.sets.join(" · ")}`);
+          const cues = cuesOf(events, settings.only && !settings.only.includes("drop") ? [] : projectDrops(resolve(dir)));
+          sfx = { hits: placeSfx(cues, settings, bank, { from: startF / fps, to: endF / fps }), settings, bank };
+          sfxCues = cues.filter((c) => c.t >= startF / fps && c.t < endF / fps).length;
+        }
+        // kf.json 에 audio(섞기 값)가 있으면 내레이션·곡을 섞은 소리를 얹는다(덕킹·끝 페이드·LUFS) — 없으면 곡만. 효과음을 깔면 audio 가 없어도 섞는다
+        const found = opts["no-music"] ? null : mixSettings(resolve(dir));
+        const mix = found ?? (sfx?.hits.length ? { audio: SFX_AUDIO, voice: undefined } : null);
+        const mixed = mix && (mix.voice || music || sfx?.hits.length)
+          ? await mixAudio({ voice: mix.voice, music, musicFrom: songFrom }, { audio: mix.audio, from: startF / fps, dur: frames / fps, total: meta.duration, out: join(tmp, "mix.wav"), sfx })
           : undefined;
         await concat({ list, out, format, music: mixed ?? music, from: mixed ? 0 : songFrom + startF / fps, dur: frames / fps });
-        if (mixed) console.error(`소리: ${mix!.voice ? "내레이션" : ""}${mix!.voice && music ? " + " : ""}${music ? "곡" : ""} → ${mix!.audio.lufs} LUFS`);
+        const layers = [mix?.voice ? "내레이션" : "", music ? "곡" : "", sfx?.hits.length ? `효과음 ${sfx.hits.length}(${sfx.settings.set})` : ""].filter(Boolean);
+        if (mixed) console.error(`소리: ${layers.join(" + ")} → ${mix!.audio.lufs} LUFS`);
       }
       const sec = (Date.now() - started) / 1000;
       const report = {
@@ -230,6 +248,15 @@ const cmd: Command = {
         motionBlur: blur,
         captions: captions ?? null,
         music: music ?? null,
+        sfx: sfx
+          ? {
+              ...sfx.settings,
+              cues: sfxCues,
+              placed: sfx.hits.length,
+              ...(sfx.measured ? { lufs: { bed: sfx.measured.bed, sfx: sfx.measured.sfx, lift: sfx.measured.lift } } : {}),
+              hits: sfx.measured?.hits ?? sfx.hits,
+            }
+          : null,
         seconds: Math.round(sec * 10) / 10,
         ...(segments ? { segments } : {}),
         markers: s.info.markers,

package/packages/cli/src/commands/update.ts

@@ -0,0 +1,66 @@
+import { createInterface } from "node:readline/promises";
+import { type Command, parseFlags } from "../command.ts";
+import { commandFor, current, isNewer, noticeLine, refresh, upgrade } from "../update.ts";
+
+async function confirm(q: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return /^(|y|yes|ㅇ|응|네)$/i.test((await rl.question(q)).trim());
+  } catch {
+    return false;
+  } finally {
+    rl.close();
+  }
+}
+
+const cmd: Command = {
+  summary: "새 판 확인·올리기 — 지금 레지스트리를 보고 새 판이면 깐 방식(npm·pnpm·bun·yarn)대로 올린다",
+  usage: `kf update            지금 확인하고 새 판이면 올린다(터미널이면 한 번 묻는다)
+kf update --check    올리지 않고 보기만
+kf update --json     {current, latest, update, command} 를 표준 출력에 — 올리지 않는다
+kf update --yes      묻지 않고 올린다(에이전트용 — 표준 오류에 「[kasaframe] 새 판 …」 줄이 보이면)
+  레지스트리는 npm 설정(npm_config_registry·~/.npmrc)을 따른다. kf 는 몇 시간에 한 번 뒤에서 확인해 두고,
+  새 판을 알면 터미널에선 명령 전에 묻고 아니면 표준 오류에 한 줄 찍는다. 끄기: KF_NO_UPDATE_CHECK=1 · CI
+  종료 코드: 0 최신이거나 올림 · 1 확인·설치 실패 · 2 올리지 않음(묻기 거절·--yes 없이 터미널 밖·레포 체크아웃)`,
+  async run(argv) {
+    const { opts } = parseFlags(argv);
+    let latest: string;
+    try {
+      latest = await refresh();
+    } catch (e) {
+      const error = (e as Error).message;
+      if (opts.json) console.log(JSON.stringify({ current, latest: null, update: false, command: null, error }));
+      else console.error(`kf update: 새 판을 확인하지 못했다 — ${error}`);
+      return 1;
+    }
+    const update = isNewer(latest, current);
+    const command = update ? commandFor(latest) : null;
+    if (opts.json) {
+      console.log(JSON.stringify({ current, latest, update, command: command?.join(" ") ?? null }));
+      return 0;
+    }
+    if (!update) {
+      console.log(`kasaframe ${current} — 최신이다${latest === current ? "" : `(레지스트리 최신 ${latest})`}`);
+      return 0;
+    }
+    if (!command) {
+      console.log(`${noticeLine(latest)}\n레포 체크아웃에서 돌고 있다 — 설치본이 아니라 올리지 않는다(git pull)`);
+      return opts.check ? 0 : 2;
+    }
+    if (opts.check) {
+      console.log(`${noticeLine(latest)}\n올리는 명령: ${command.join(" ")}`);
+      return 0;
+    }
+    if (!opts.yes) {
+      if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+        console.error(`${noticeLine(latest)}\n터미널이 아니라 묻지 못한다 — 묻지 않고 올리려면 kf update --yes`);
+        return 2;
+      }
+      if (!(await confirm(`kasaframe ${current} → ${latest} 로 올릴까(${command.join(" ")})? [Y/n] `))) return 2;
+    }
+    if (!upgrade(command, latest)) return 1;
+    console.log(`kasaframe ${latest} 로 올렸다`);
+    return 0;
+  },
+};
+export default cmd;