elanous 0.2.8 → 0.2.9

package/src/nexus/api/ops-seats-sources.ts

@@ -0,0 +1,65 @@
+// Live sources for /v1/ops/seats: the coordination PR and merged PRs through gh (automation App identity, proxy variables
+// removed — same rule as decision replies), the release checklist, and the decision ledger. Each failure becomes null upstream.
+import { DecisionLedger } from '../../decisions/decision-ledger.js';
+import { devVersion, listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
+import { getUserConfig } from '../../user-config.js';
+import { kstDayRange, type ChannelComment, type MergedPr, type SeatsSources } from './ops-seats.js';
+
+const GH_TIMEOUT_MS = 20_000;
+
+async function ghLines(args: string[]): Promise<string[] | null> {
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(process.env)) if (v !== undefined && !/^(https?|all|no)_proxy$/i.test(k)) env[k] = v;
+  try {
+    const { githubAutomationToken } = await import('../../auth/github-app-token.js');
+    const token = githubAutomationToken();
+    if (token) env.GH_TOKEN = token;
+  } catch { /* machine login */ }
+  const proc = Bun.spawn(['gh', ...args], { stdin: 'ignore', stdout: 'pipe', stderr: 'ignore', env });
+  const timer = setTimeout(() => proc.kill(), GH_TIMEOUT_MS);
+  try {
+    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    return code === 0 ? out.split('\n').filter(Boolean) : null;
+  } finally { clearTimeout(timer); }
+}
+
+function channelTarget(): { repo: string; pr: string } | null {
+  const raw = (getUserConfig().raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  const m = typeof raw === 'string' ? /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(raw.trim()) : null;
+  return m ? { repo: m[1]!, pr: m[2]! } : null;
+}
+
+function nextPatch(version: string): string {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return `${major}.${minor}.${patch! + 1}`;
+}
+
+export function liveSeatsSources(): SeatsSources {
+  return {
+    async channel(date) {
+      const target = channelTarget();
+      if (!target) return null;
+      const lines = await ghLines(['api', '--paginate', `repos/${target.repo}/issues/${target.pr}/comments?since=${kstDayRange(date).start}&per_page=100`,
+        '--jq', '.[] | {body: .body, createdAt: .created_at} | tojson']);
+      return lines?.map((line) => JSON.parse(line) as ChannelComment) ?? null;
+    },
+    async merged(date) {
+      const target = channelTarget();
+      if (!target) return null;
+      const { start, end } = kstDayRange(date);
+      const lines = await ghLines(['pr', 'list', '--repo', target.repo, '--state', 'merged', '--limit', '300',
+        '--search', `merged:${start.slice(0, 19)}Z..${end.slice(0, 19)}Z`, '--json', 'number,title,body,mergedAt', '--jq', '.[] | tojson']);
+      return lines?.map((line) => JSON.parse(line) as MergedPr) ?? null;
+    },
+    checklist() {
+      const dev = devVersion();
+      const next = listChecklist(nextPatch(dev)).items;
+      const current = listChecklist(dev).items;
+      const all: ChecklistItem[] = [...current, ...next];
+      return { current: next.length ? next : current, all };
+    },
+    openDecisionRaisers() {
+      return new DecisionLedger().list({ status: 'open' }).map((entry) => entry.raisedBy.agent);
+    },
+  };
+}

package/src/nexus/api/ops-seats.ts

@@ -0,0 +1,114 @@
+// GET /v1/ops/seats?date=YYYY-MM-DD — one row per seat: latest channel line, PRs landed that day, red items, open decisions.
+// A source that could not be read is null, never 0 («못 읽음» ≠ «없음»). Contract: 내부 문서 `DESIGN-ops3-seat-board-and-public-demo-2026-10-02` §1.
+import { debug, redactSecretText } from '../../debug/log.js';
+import type { ChecklistItem } from '../../release-loop/checklist.js';
+import { canonicalSeatId } from '../../msg/msg-store.js';
+
+export const SEATS = [
+  { seat: 'OP', role: 'COO' }, { seat: 'TC', role: 'CTO' }, { seat: 'MK', role: 'CMO' }, { seat: 'UX', role: 'CXO' },
+] as const;
+export const SEATS_CACHE_MS = 60_000;
+
+export interface ChannelComment { body: string; createdAt: string }
+export interface MergedPr { number: number; title: string; body: string; mergedAt: string }
+export interface SeatsSources {
+  /** Coordination-channel comments created on `date` (KST) or later; null when unreadable. */
+  channel(date: string): Promise<ChannelComment[] | null>;
+  /** PRs merged on `date` (KST); null when unreadable. */
+  merged(date: string): Promise<MergedPr[] | null>;
+  /** Checklist items of the version being worked on (counts, red) and of every version known (id → owner). */
+  checklist(): { current: ChecklistItem[]; all: ChecklistItem[] } | null;
+  /** `raisedBy.agent` of every open decision. */
+  openDecisionRaisers(): string[] | null;
+}
+
+export interface SeatRow {
+  seat: string; role: string;
+  now: { text: string; at: string } | null;
+  landed: Array<{ pr: number; title: string; at: string; checklistId: string | null }> | null;
+  blocked: Array<{ id: string; title: string; status: 'red' }> | null;
+  pendingDecisions: number | null;
+  checklist: { green: number; yellow: number; red: number; done: number } | null;
+}
+
+function seatOf(value: string | undefined): string | null {
+  if (!value) return null;
+  try { return canonicalSeatId(value); } catch { return null; }
+}
+
+const clip = (text: string, max: number) => redactSecretText(text).slice(0, max);
+
+/** First checklist id that appears as a whole word in the title, else in the body. */
+function checklistIdOf(pr: MergedPr, ids: string[]): string | null {
+  for (const text of [pr.title, pr.body]) {
+    const found = ids.map((id) => ({ id, at: text.search(new RegExp(`(?<![A-Za-z0-9])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9])`)) }))
+      .filter((hit) => hit.at >= 0).sort((a, b) => a.at - b.at || b.id.length - a.id.length);
+    if (found.length) return found[0]!.id;
+  }
+  return null;
+}
+
+export async function buildSeatsBoard(date: string, sources: SeatsSources): Promise<{ date: string; seats: SeatRow[] }> {
+  const [channel, merged] = await Promise.all([
+    sources.channel(date).catch(() => null), sources.merged(date).catch(() => null),
+  ]);
+  let checklist: ReturnType<SeatsSources['checklist']> = null;
+  try { checklist = sources.checklist(); } catch { checklist = null; }
+  let raisers: string[] | null = null;
+  try { raisers = sources.openDecisionRaisers(); } catch { raisers = null; }
+
+  const owners = new Map<string, string>();
+  for (const item of checklist?.all ?? []) { const seat = seatOf(item.owner); if (seat) owners.set(item.id, seat); }
+  const ids = [...owners.keys()];
+  const landedBySeat = new Map<string, NonNullable<SeatRow['landed']>>();
+  for (const pr of merged ?? []) {
+    const id = checklistIdOf(pr, ids);
+    const seat = id ? owners.get(id) : undefined;
+    if (!seat) continue; // ⛔ not by commit author — every seat lands through the same account.
+    landedBySeat.set(seat, [...(landedBySeat.get(seat) ?? []), { pr: pr.number, title: clip(pr.title, 80), at: pr.mergedAt, checklistId: id }]);
+  }
+
+  const seats = SEATS.map(({ seat, role }): SeatRow => {
+    const latest = channel?.filter((c) => c.body.trimStart().startsWith(`**[${seat}]**`)).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+    const mine = checklist?.current.filter((item) => seatOf(item.owner) === seat);
+    return {
+      seat, role,
+      now: latest ? { text: clip(latest.body.trimStart().split('\n')[0]!, 120), at: latest.createdAt } : null,
+      landed: merged === null || checklist === null ? null : (landedBySeat.get(seat) ?? []).sort((a, b) => a.at.localeCompare(b.at)),
+      blocked: mine ? mine.filter((item) => item.status === 'red').map((item) => ({ id: item.id, title: clip(item.title, 80), status: 'red' as const })) : null,
+      pendingDecisions: raisers === null ? null : raisers.filter((agent) => seatOf(agent) === seat).length,
+      checklist: mine ? {
+        green: mine.filter((i) => i.status === 'green').length, yellow: mine.filter((i) => i.status === 'yellow').length,
+        red: mine.filter((i) => i.status === 'red').length, done: mine.filter((i) => i.status === 'done').length,
+      } : null,
+    };
+  });
+  debug.log('ops.seats', 'built', {
+    date, channel: channel === null ? 'unreadable' : channel.length, merged: merged === null ? 'unreadable' : merged.length,
+    checklist: checklist !== null, decisions: raisers !== null,
+  });
+  return { date, seats };
+}
+
+/** KST calendar day → [start, end) in UTC ISO. */
+export function kstDayRange(date: string): { start: string; end: string } {
+  const start = new Date(`${date}T00:00:00+09:00`);
+  return { start: start.toISOString(), end: new Date(start.getTime() + 86_400_000).toISOString() };
+}
+
+export function todayKst(now = new Date()): string {
+  return new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul' }).format(now);
+}
+
+/** One snapshot per date for 60 s; concurrent requests share one build. */
+export function createSeatsCache(sources: SeatsSources, now: () => number = Date.now, ttlMs = SEATS_CACHE_MS) {
+  const slots = new Map<string, { at: number; value: Promise<{ date: string; seats: SeatRow[] }> }>();
+  return (date: string) => {
+    const slot = slots.get(date);
+    if (slot && now() - slot.at < ttlMs) return slot.value;
+    const value = buildSeatsBoard(date, sources);
+    slots.set(date, { at: now(), value });
+    value.catch(() => slots.delete(date));
+    return value;
+  };
+}

package/src/nexus/api/public-routes.ts

@@ -36,6 +36,12 @@ export const PUBLIC_ROUTES: Array<PublicRoute> = [
     path: '/v1/push/vapid-public-key',
     why: 'PWA fetches the VAPID public key before a bearer is pasted',
   },
+  {
+    method: 'GET',
+    match: 'exact',
+    path: '/v1/me',
+    why: 'operator signal only (draw the ops area or not); false unless operator.enabled, no other data',
+  },
   {
     method: 'GET',
     match: 'exact',
@@ -56,6 +62,13 @@ export const PUBLIC_ROUTES: Array<PublicRoute> = [
     selfVerified: true,
     why: 'Pod GitHub App credential relay verifies its own run-scoped gh-credential token before minting a repository-scoped installation token',
   },
+  {
+    method: 'POST',
+    match: 'exact',
+    path: '/v1/setup/claim',
+    selfVerified: true,
+    why: 'one-use setup link is verified by the claim handler without an owner bearer',
+  },
   {
     method: 'GET',
     match: 'prefix',
@@ -76,7 +89,7 @@ export function isPublicRoute(
 ): boolean {
   for (const route of PUBLIC_ROUTES) {
     if (route.method !== method) continue;
-    if (route.path.startsWith('/v1/setup/') && !ctx.setupMode) continue;
+    if (route.path.startsWith('/v1/setup/') && route.path !== '/v1/setup/claim' && !ctx.setupMode) continue;
     if (route.match === 'exact') {
       if (pathname === route.path) return true;
     } else if (pathname === route.path || pathname.startsWith(route.path)) {

package/src/nexus/api/setup-claim.ts

@@ -0,0 +1,21 @@
+import { claimSetupLinkToken } from '../../auth/setup-link-tokens.js';
+import { jsonResponse } from './json-response.js';
+
+/** A setup link is its own credential; this handler never reads the owner bearer. */
+export async function handleSetupClaim(req: Request): Promise<Response> {
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  if (!body || typeof body !== 'object' || Array.isArray(body)
+    || typeof (body as Record<string, unknown>).t !== 'string'
+    || !(body as { t: string }).t.trim()) {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+
+  const result = claimSetupLinkToken((body as { t: string }).t);
+  if (!result.ok) return jsonResponse({ error: result.reason }, 401);
+  return jsonResponse({ scope: 'setup', bearer: result.bearer, expiresAt: result.expiresAt });
+}

package/src/nexus/config/secrets/file-backend.ts

@@ -5,8 +5,10 @@
 // without touching caller code. The legacy module re-exports this
 // backend's accessor functions to preserve backwards compatibility.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, chmodSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
+import { acquireLockSync } from '../../../storage/file-lock.js';
 import { SECRETS_VERSION, type SecretsFile } from '../types.js';
 import { secretsPath } from '../paths.js';
 import type { SecretBackend, SecretBackendAvailability, SyncReadableBackend } from './types.js';
@@ -21,20 +23,47 @@ function readSecretsFile(): SecretsFile {
   try {
     const raw = readFileSync(path, 'utf-8');
     const parsed = JSON.parse(raw) as Partial<SecretsFile>;
-    if (parsed.version !== SECRETS_VERSION) return defaultSecrets();
-    return {
-      version: SECRETS_VERSION,
-      secrets: (parsed.secrets ?? {}) as Record<string, string>,
-    };
-  } catch {
-    return defaultSecrets();
+    if (parsed?.version !== SECRETS_VERSION || !parsed.secrets || typeof parsed.secrets !== 'object'
+      || Array.isArray(parsed.secrets) || Object.values(parsed.secrets).some(value => typeof value !== 'string')) {
+      throw new Error('invalid secrets file version or contents');
+    }
+    return { version: SECRETS_VERSION, secrets: parsed.secrets };
+  } catch (error) {
+    throw new Error(`cannot read secrets file at ${path}`, { cause: error });
   }
 }
 
 function writeSecretsFile(s: SecretsFile): void {
   const path = secretsPath();
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(s, null, 2), { mode: 0o600 });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  const backupTmp = `${path}.${randomUUID()}.bak.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(s, null, 2), { mode: 0o600, flag: 'wx' });
+    if (existsSync(path)) {
+      copyFileSync(path, backupTmp);
+      chmodSync(backupTmp, 0o600);
+      renameSync(backupTmp, `${path}.bak`);
+    }
+    renameSync(tmp, path);
+  } finally {
+    if (existsSync(tmp)) unlinkSync(tmp);
+    if (existsSync(backupTmp)) unlinkSync(backupTmp);
+  }
+}
+
+function modifySecretsFile(change: (s: SecretsFile) => boolean): boolean {
+  const path = secretsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const release = acquireLockSync(`${path}.lock`);
+  try {
+    const s = readSecretsFile();
+    if (!change(s)) return false;
+    writeSecretsFile(s);
+    return true;
+  } finally {
+    release();
+  }
 }
 
 const syncReadable: SyncReadableBackend = {
@@ -46,16 +75,14 @@ export const fileBackend: SecretBackend = {
   id: 'file',
   async get(id) { return syncReadable.getSync(id); },
   async set(id, value) {
-    const s = readSecretsFile();
-    s.secrets[id] = value;
-    writeSecretsFile(s);
+    modifySecretsFile(s => { s.secrets[id] = value; return true; });
   },
   async delete(id) {
-    const s = readSecretsFile();
-    if (!(id in s.secrets)) return false;
-    delete s.secrets[id];
-    writeSecretsFile(s);
-    return true;
+    return modifySecretsFile(s => {
+      if (!Object.hasOwn(s.secrets, id)) return false;
+      delete s.secrets[id];
+      return true;
+    });
   },
   async list() { return syncReadable.listSync(); },
   async isAvailable(): Promise<SecretBackendAvailability> {
@@ -74,5 +101,16 @@ export function readSecretsFileRaw(): SecretsFile {
 }
 
 export function writeSecretsFileRaw(s: SecretsFile): void {
-  writeSecretsFile(s);
+  if (s.version !== SECRETS_VERSION || !s.secrets || typeof s.secrets !== 'object'
+    || Array.isArray(s.secrets) || Object.values(s.secrets).some(value => typeof value !== 'string')) {
+    throw new Error('invalid secrets file version or contents');
+  }
+  const path = secretsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const release = acquireLockSync(`${path}.lock`);
+  try {
+    writeSecretsFile(s);
+  } finally {
+    release();
+  }
 }

package/src/onboarding/first-run-doctor.ts

@@ -0,0 +1,54 @@
+import { delimiter, join, win32 } from 'node:path';
+import { applyDoctorFixes, planDoctorFixes, type DoctorFixDeps, type DoctorFixItem } from '../cli/doctor-fix.js';
+import { staticToolBinDir } from '../cli/doctor-static-tools.js';
+import { debug } from '../debug/log.js';
+
+const AUTOMATIC = new Set<DoctorFixItem['id']>(['private-files', 'key-cache-permissions', 'static-tools']);
+const DEFERRED = new Set<DoctorFixItem['id']>(['install-path', 'bun-tmpdir']);
+const LATER_LINE = '나중에: elanous doctor --fix (셸 시작 파일 수정)';
+
+export interface FirstRunDoctorResult {
+  fixed: string[];
+  skipped: string[];
+  failed: string[];
+  later: string[];
+  lines: string[];
+}
+
+/** 첫 실행에서는 동의가 필요 없는 수리만 실행하고, 셸 시작 파일은 손대지 않는다. */
+export function runFirstRunDoctor(deps: DoctorFixDeps): FirstRunDoctorResult {
+  const result: FirstRunDoctorResult = { fixed: [], skipped: [], failed: [], later: [], lines: [] };
+  const record = (id: string, outcome: 'fixed' | 'skipped' | 'failed', reason?: string) => {
+    result[outcome].push(id);
+    if (outcome === 'failed') result.lines.push(`doctor: ${id} 수리 실패 — ${reason || '원인 불명'}`);
+    try { debug.log('doctor.first-run', outcome, { id }); } catch { /* 관측 실패가 첫 실행을 막지 않는다. */ }
+  };
+
+  try {
+    const windows = deps.readiness?.platform === 'win32';
+    const prefix = deps.readiness?.installPrefix;
+    const bin = typeof prefix === 'string' && prefix.trim()
+      ? windows ? win32.join(prefix.trim(), 'bin') : join(prefix.trim(), 'bin')
+      : staticToolBinDir(deps.env ?? process.env, deps.home);
+    const separator = windows ? ';' : delimiter;
+    const entries = (process.env.PATH ?? '').split(separator);
+    if (!entries.some((entry) => windows ? entry.toLowerCase() === bin.toLowerCase() : entry === bin)) {
+      process.env.PATH = [bin, process.env.PATH].filter(Boolean).join(separator);
+    }
+
+    const plan = planDoctorFixes(deps);
+    for (const item of plan.items) {
+      if (DEFERRED.has(item.id) && item.status === 'fixable') result.later.push(item.id);
+    }
+    const applied = applyDoctorFixes(deps, true, AUTOMATIC);
+    for (const item of applied.items) {
+      if (AUTOMATIC.has(item.id) && item.result === 'failed') record(item.id, 'failed', item.reason);
+      else if (AUTOMATIC.has(item.id) && item.result === 'fixed') record(item.id, 'fixed');
+      else record(item.id, 'skipped');
+    }
+  } catch {
+    record('doctor', 'failed', '계획 또는 적용 중 예외');
+  }
+  if (result.later.length) result.lines.push(LATER_LINE);
+  return result;
+}

package/src/release-loop/checklist.ts

@@ -1,9 +1,7 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { Database } from 'bun:sqlite';
-import { dirname, join } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as store from './feature-store.js';
 import { debug } from '../debug/log.js';
-import { releaseLedgerRoot } from '../instance/resolve.js';
 import { CliUserError } from '../cli/cli-user-error.js';
 
 export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
@@ -43,67 +41,12 @@ export function devVersion(): string {
   return (JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf8')) as { version: string }).version;
 }
 
-function releasedVersion(): string {
-  const dir = join(releaseLedgerRoot(), 'release');
-  if (!existsSync(dir)) return '';
-  return readdirSync(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v) && existsSync(join(dir, v, 'release.json')))
-    .filter((v) => {
-      try { const record = JSON.parse(readFileSync(join(dir, v, 'release.json'), 'utf8')) as { version?: string; publishedAt?: string }; return record.version === v && typeof record.publishedAt === 'string'; }
-      catch { return false; }
-    })
-    .sort((a, b) => {
-      const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
-      return (bb[0]! - aa[0]!) || (bb[1]! - aa[1]!) || (bb[2]! - aa[2]!);
-    })[0] ?? '';
-}
-
-function pathFor(v: string): string {
-  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(v)) throw new CliUserError(`체크리스트 판이 아니다: ${v}`);
-  return join(releaseLedgerRoot(), 'release', v, 'checklist.json');
-}
-
 export function listChecklist(v: string): Checklist {
-  const path = pathFor(v);
-  if (existsSync(path)) {
-    const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
-    refresh(data);
-    return data;
-  }
-  return { version: v, released: releasedVersion(), dev: devVersion(), items: [], history: [] };
+  return store.list(v);
 }
 
-// SQLite's OS-backed write lock is released when the owning process exits, even without a finally block.
-// Hold it across the JSON read/modify/atomic-rename sequence so writers never use stale snapshots.
 function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
-  const path = pathFor(v);
-  mkdirSync(dirname(path), { recursive: true });
-  const lock = `${path}.mutex.sqlite`;
-  const db = new Database(lock, { create: true, strict: true });
-  try {
-    chmodSync(lock, 0o600);
-    db.exec('PRAGMA busy_timeout = 10000');
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      const data = listChecklist(v);
-      if (apply(data)) save(v, data);
-      db.exec('COMMIT');
-      return data;
-    } catch (error) {
-      db.exec('ROLLBACK');
-      throw error;
-    }
-  } finally { db.close(); }
-}
-
-function save(v: string, data: Checklist): void {
-  const path = pathFor(v);
-  mkdirSync(dirname(path), { recursive: true });
-  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
-    chmodSync(temp, 0o600);
-    renameSync(temp, path);
-  } finally { if (existsSync(temp)) rmSync(temp); }
+  return store.mutate(v, store.releasedVersion(), devVersion(), apply);
 }
 
 function change(data: Checklist, id: string, field: string, from: unknown, to: unknown, by: string, at: string): void {
@@ -111,8 +54,6 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
   debug.log('release-loop.checklist', 'change', { version: data.version, id, field, from: from ?? null, to: to ?? null, by });
 }
 
-function refresh(data: Checklist): void { data.released = releasedVersion(); data.dev = devVersion(); }
-
 export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');