@hanmariyang/drafting 1.6.2

package/api/dist/providers/cli.js

@@ -0,0 +1,391 @@
+/**
+ * CLI(데몬) 프로바이더 — 사용자의 로컬 에이전트 CLI(Claude Code)를 스폰해
+ * 구독 인증으로 생성한다. API 키가 필요 없다 (coxpit-oss providers.ts 계보).
+ *
+ * 격리 원칙 (2026-08-20 실측): CLI 는 cwd 의 CLAUDE.md·메모리·스킬을 주입하므로
+ *   - 빈 전용 cwd (dataDir/agent)
+ *   - --setting-sources "" (사용자/프로젝트 설정 차단)
+ *   - --system-prompt 교체 (+ 동적 섹션 제외)
+ * 없이는 워크스페이스 맥락이 문서에 새어 들어간다.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { config } from "../lib/config.js";
+import { getSetting } from "../db/repos.js";
+const HOME = os.homedir();
+/** 설치 관리자와 무관한 표준 위치들(존재하면 바로 사용). */
+const FIXED_CANDIDATES = [
+    '/opt/homebrew/bin/claude',
+    '/usr/local/bin/claude',
+    path.join(HOME, '.local', 'bin', 'claude'),
+    path.join(HOME, '.claude', 'local', 'claude'),
+    path.join(HOME, '.volta', 'bin', 'claude'),
+    path.join(HOME, '.asdf', 'shims', 'claude'),
+];
+function safeExists(p) {
+    try {
+        return !!p && fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/** semver-ish 문자열 내림차순 비교 (최신 노드 버전 우선). */
+function cmpVersionDesc(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pb[i] ?? 0) - (pa[i] ?? 0);
+        if (d)
+            return d;
+    }
+    return 0;
+}
+/**
+ * nvm·fnm·asdf·n 처럼 노드 버전 디렉터리 안에 claude 를 심는 매니저를 글롭한다.
+ * GUI 앱은 이 경로들을 PATH 로 못 보므로 직접 훑는다. 버전이 여럿이면 최신을 앞에.
+ * 순수하게 테스트하도록 home 을 주입 가능.
+ */
+export function nodeManagerBins(home = HOME) {
+    const roots = [
+        { dir: path.join(home, '.nvm', 'versions', 'node'), suffix: ['bin', 'claude'] },
+        { dir: path.join(home, '.fnm', 'node-versions'), suffix: ['installation', 'bin', 'claude'] },
+        { dir: path.join(home, 'Library', 'Application Support', 'fnm', 'node-versions'), suffix: ['installation', 'bin', 'claude'] },
+        { dir: path.join(home, '.asdf', 'installs', 'nodejs'), suffix: ['bin', 'claude'] },
+        { dir: path.join(home, 'n', 'versions', 'node'), suffix: ['bin', 'claude'] },
+    ];
+    const out = [];
+    for (const { dir, suffix } of roots) {
+        let versions;
+        try {
+            versions = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        versions.sort(cmpVersionDesc);
+        for (const v of versions) {
+            const p = path.join(dir, v, ...suffix);
+            if (safeExists(p))
+                out.push(p);
+        }
+    }
+    return out;
+}
+/** 설정에 저장된 수동 경로(최우선). DB 미초기화(테스트)면 조용히 무시. */
+function settingBin() {
+    try {
+        const v = getSetting('agent_bin_path');
+        return typeof v === 'string' ? v.trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
+let cachedBin;
+/**
+ * claude 바이너리를 찾는다. 우선순위:
+ *   1) 설정 수동 경로 → 2) DRAFTING_AGENT_BIN → 3) PATH(which) →
+ *   4) 표준 위치 → 5) 노드 버전 매니저(nvm/fnm/asdf/n) 글롭
+ * GUI 앱은 셸 PATH 를 못 물려받으므로 4·5 의 직접 탐색이 핵심이다.
+ */
+export function resolveCliBin() {
+    if (cachedBin !== undefined)
+        return cachedBin;
+    for (const cand of [settingBin(), (process.env.DRAFTING_AGENT_BIN ?? '').trim()]) {
+        if (safeExists(cand))
+            return (cachedBin = cand);
+    }
+    const onPath = spawnSync('which', ['claude'], { encoding: 'utf8' });
+    if (onPath.status === 0 && onPath.stdout.trim())
+        return (cachedBin = onPath.stdout.trim());
+    for (const cand of FIXED_CANDIDATES) {
+        if (safeExists(cand))
+            return (cachedBin = cand);
+    }
+    const managed = nodeManagerBins();
+    if (managed.length)
+        return (cachedBin = managed[0]);
+    return (cachedBin = null);
+}
+export function cliAvailable() {
+    return resolveCliBin() !== null;
+}
+/** 세션 캐시 무효화 (설정에서 경로를 바꾼 직후 등) */
+export function resetCliBinCache() {
+    cachedBin = undefined;
+}
+/**
+ * CLI 스폰용 env. GUI 앱의 빈약한 PATH 로는 nvm/fnm 의 claude 셔뱅
+ * (`#!/usr/bin/env node`)이 node 를 못 찾아 실패한다 → 바이너리와 같은 dir
+ * (그 안에 node 가 함께 있다) + 표준 위치를 PATH 앞에 얹는다. 테스트 가능하도록 분리.
+ */
+export function cliSpawnEnv(bin, baseEnv = process.env) {
+    const prepend = [
+        path.dirname(bin),
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        path.join(HOME, '.local', 'bin'),
+        '/usr/bin',
+        '/bin',
+    ];
+    const existing = baseEnv.PATH ? baseEnv.PATH.split(path.delimiter) : [];
+    const seen = new Set();
+    const merged = [...prepend, ...existing].filter((d) => d && !seen.has(d) && seen.add(d));
+    const env = { ...baseEnv, PATH: merged.join(path.delimiter) };
+    // 헤드리스 한 방(one-shot) 생성에서 확장 사고(extended thinking)가 스톨/토큰 소진으로
+    // 빈 결과·is_error 를 내는 것을 막는다(회고 교훈). 사용자가 명시 설정하면 존중.
+    if (env.MAX_THINKING_TOKENS === undefined)
+        env.MAX_THINKING_TOKENS = '0';
+    return env;
+}
+/** API 모델 id → CLI 별칭. CLI 는 풀 id 도 받지만 별칭이 구독 기본값과 정합. */
+function cliModel(model) {
+    const m = model.toLowerCase();
+    if (m.includes('haiku'))
+        return 'haiku';
+    if (m.includes('opus'))
+        return 'opus';
+    if (m.includes('sonnet'))
+        return 'sonnet';
+    return model || 'sonnet';
+}
+/** stream-json 한 줄 → 텍스트 델타 (없으면 null). 테스트에서 직접 검증한다. */
+export function deltaFromLine(line) {
+    let ev;
+    try {
+        ev = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (ev.type === 'stream_event' && ev.event?.delta?.type === 'text_delta') {
+        return ev.event.delta.text ?? null;
+    }
+    return null;
+}
+/** 최종 assistant 텍스트 (partial 미지원 CLI 폴백용). */
+export function textFromAssistantLine(line) {
+    let ev;
+    try {
+        ev = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (ev.type !== 'assistant')
+        return null;
+    const parts = (ev.message?.content ?? [])
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text ?? '');
+    return parts.length ? parts.join('') : null;
+}
+export function errorFromResultLine(line) {
+    let ev;
+    try {
+        ev = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (ev.type === 'result' && ev.is_error)
+        return ev.result || 'agent CLI returned an error';
+    return null;
+}
+/**
+ * 구독 차단(조직이 Claude Code 구독 접근을 끈 경우)·미로그인 등 인증 계열 에러에
+ * 앱 안에서의 해결 경로를 덧붙인다. 원문은 보존한다.
+ */
+export function actionableCliError(msg) {
+    if (/disabled Claude subscription|API key instead|log ?in|authenticat|OAuth|credential/i.test(msg)) {
+        return (`${msg} — 설정(⌘,)에서 엔진을 API 키(BYOK) 모드로 전환해 Anthropic/OpenRouter 키를 등록하거나, ` +
+            `이 머신의 claude CLI 를 구독이 허용된 계정으로 다시 로그인(claude /login)하세요.`);
+    }
+    return msg;
+}
+function agentCwd() {
+    const dir = path.join(path.dirname(config.databasePath), 'agent');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+const AUTH_BLOCK_RE = /disabled Claude subscription|subscription access|API key instead|log ?in|not logged|authenticat|OAuth|credential|invalid API key|unauthorized|401|403/i;
+/**
+ * `--version`(존재 확인)을 넘어 실제 생성 권한을 검증한다. 조직이 Claude Code
+ * 구독 접근을 끈 계정은 CLI 가 설치·로그인돼 있어도 첫 생성에서 거부되므로,
+ * 온보딩에서 '키 없이 시작'을 누르는 즉시 이 검증으로 미리 잡아 BYOK 로 보낸다.
+ * 검증용 최소 프롬프트 + haiku 로 토큰을 아낀다.
+ */
+export async function verifyCliAccess(binOverride) {
+    const bin = binOverride ?? resolveCliBin();
+    if (!bin) {
+        return { ok: false, blocked: false, detail: 'Claude Code CLI 를 찾지 못했습니다 (claude 설치·로그인 필요)' };
+    }
+    return new Promise((resolve) => {
+        const child = spawn(bin, ['-p', '응답으로 OK 한 단어만 출력', '--output-format', 'json', '--max-turns', '1', '--model', 'haiku', '--setting-sources', ''], { cwd: agentCwd(), env: cliSpawnEnv(bin), stdio: ['ignore', 'pipe', 'pipe'] });
+        let out = '';
+        let err = '';
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* gone */ }
+            resolve({ ok: false, blocked: false, detail: 'CLI 응답 시간 초과 — 네트워크·로그인 상태를 확인하세요.' });
+        }, 30000);
+        child.stdout.on('data', (c) => { out += c.toString(); });
+        child.stderr.on('data', (c) => { err += c.toString(); });
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            resolve({ ok: false, blocked: false, detail: `CLI 실행 실패: ${e.message}` });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            let isErr = false;
+            let resultText = '';
+            for (const line of out.split('\n')) {
+                const t = line.trim();
+                if (!t)
+                    continue;
+                try {
+                    const ev = JSON.parse(t);
+                    if (ev.type === 'result') {
+                        isErr = !!ev.is_error;
+                        resultText = ev.result ?? '';
+                    }
+                }
+                catch { /* not json */ }
+            }
+            const combined = `${resultText}\n${err}`;
+            const blocked = AUTH_BLOCK_RE.test(combined);
+            if (code === 0 && !isErr && !blocked) {
+                return resolve({ ok: true, blocked: false, detail: 'Claude Code 생성 권한 확인됨' });
+            }
+            resolve({ ok: false, blocked, detail: actionableCliError(resultText || err || `CLI 종료 코드 ${code}`) });
+        });
+    });
+}
+export class CliProvider {
+    id = 'cli';
+    bin;
+    constructor(bin) {
+        const resolved = bin ?? resolveCliBin();
+        if (!resolved) {
+            throw new Error('Claude Code CLI 를 찾지 못했습니다. 설치 후 로그인하거나(claude), 설정에서 API 키(BYOK) 모드로 전환하세요.');
+        }
+        this.bin = resolved;
+    }
+    async *streamChat(params) {
+        const system = params.messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const prompt = params.messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const args = [
+            '-p', prompt,
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--include-partial-messages',
+            '--max-turns', '1',
+            '--model', cliModel(params.model),
+            '--setting-sources', '',
+        ];
+        if (system)
+            args.push('--system-prompt', system, '--exclude-dynamic-system-prompt-sections');
+        const child = spawn(this.bin, args, {
+            cwd: agentCwd(),
+            env: cliSpawnEnv(this.bin),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (params.signal) {
+            const onAbort = () => { try {
+                child.kill('SIGTERM');
+            }
+            catch { /* gone */ } };
+            if (params.signal.aborted)
+                onAbort();
+            else
+                params.signal.addEventListener('abort', onAbort, { once: true });
+        }
+        let stderrTail = '';
+        child.stderr.on('data', (c) => {
+            stderrTail = (stderrTail + c.toString()).slice(-2000);
+        });
+        let buffer = '';
+        let sawDelta = false;
+        let fallbackText = '';
+        let resultError = null;
+        const lines = [];
+        let resolveMore = null;
+        let done = false;
+        let spawnError = null;
+        child.stdout.on('data', (c) => {
+            buffer += c.toString();
+            const parts = buffer.split('\n');
+            buffer = parts.pop() ?? '';
+            for (const p of parts)
+                if (p.trim())
+                    lines.push(p);
+            resolveMore?.();
+        });
+        child.on('error', (e) => { spawnError = e; done = true; resolveMore?.(); });
+        child.on('close', () => { if (buffer.trim())
+            lines.push(buffer); done = true; resolveMore?.(); });
+        while (!done || lines.length) {
+            if (!lines.length) {
+                await new Promise((res) => { resolveMore = res; });
+                resolveMore = null;
+                continue;
+            }
+            const line = lines.shift();
+            const delta = deltaFromLine(line);
+            if (delta !== null) {
+                sawDelta = true;
+                yield delta;
+                continue;
+            }
+            const full = textFromAssistantLine(line);
+            if (full !== null)
+                fallbackText += full;
+            resultError = resultError ?? errorFromResultLine(line);
+        }
+        if (spawnError)
+            throw new Error(`agent CLI 실행 실패: ${spawnError.message}`);
+        if (resultError) {
+            // 일반 메시지("agent CLI returned an error")만으로는 원인을 알 수 없다 → stderr 꼬리를 덧붙여 노출.
+            const tail = stderrTail.trim();
+            const detail = tail ? `${resultError} · ${tail.slice(-300)}` : resultError;
+            throw new Error(actionableCliError(detail));
+        }
+        if (!sawDelta && fallbackText)
+            yield fallbackText;
+        if (!sawDelta && !fallbackText && child.exitCode !== 0) {
+            throw new Error(actionableCliError(`agent CLI 종료 코드 ${child.exitCode}: ${stderrTail.slice(-300)}`));
+        }
+    }
+    async testConnection(_model) {
+        return new Promise((resolve) => {
+            const child = spawn(this.bin, ['--version'], { env: cliSpawnEnv(this.bin), stdio: ['ignore', 'pipe', 'pipe'] });
+            let out = '';
+            const timer = setTimeout(() => {
+                try {
+                    child.kill();
+                }
+                catch { /* gone */ }
+                resolve({ ok: false, detail: 'CLI 응답 시간 초과' });
+            }, 5000);
+            child.stdout.on('data', (c) => { out += c.toString(); });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                resolve(code === 0 ? { ok: true, detail: out.trim() } : { ok: false, detail: `종료 코드 ${code}` });
+            });
+            child.on('error', (e) => {
+                clearTimeout(timer);
+                resolve({ ok: false, detail: e.message });
+            });
+        });
+    }
+}

package/api/dist/providers/index.js

@@ -0,0 +1,68 @@
+import { config } from "../lib/config.js";
+import { getDecryptedKey } from "../db/repos.js";
+import { AnthropicProvider } from "./byok/anthropic.js";
+import { OpenAIProvider, OpenRouterProvider } from "./byok/openai-compat.js";
+import { StubProvider } from "./stub.js";
+import { ManagedProvider } from "./managed.js";
+import { CliProvider, cliAvailable } from "./cli.js";
+import { getSetting } from "../db/repos.js";
+export class ProviderKeyError extends Error {
+    provider;
+    constructor(provider) {
+        super(`No API key configured for provider "${provider}". Add one in Settings.`);
+        this.name = 'ProviderKeyError';
+        this.provider = provider;
+    }
+}
+/**
+ * Resolve an AIProvider for a given provider id. This is the ONLY place a
+ * concrete provider is constructed — all AI calls funnel through here (G-07).
+ *   - MANAGED_TIER=true  -> ManagedProvider (v2, interface only)
+ *   - AI_STUB=1          -> StubProvider (offline, deterministic)
+ *   - otherwise          -> BYOK provider using the decrypted key
+ */
+/** 엔진 모드: 'cli'(Claude Code 구독, 기본) | 'byok'(API 키). 미설정 시 CLI 감지로 결정. */
+export function aiMode() {
+    const saved = getSetting('ai_mode');
+    if (saved === 'cli' || saved === 'byok')
+        return saved;
+    return cliAvailable() ? 'cli' : 'byok';
+}
+export function resolveProvider(providerId, opts) {
+    if (config.managedTier)
+        return new ManagedProvider();
+    if (config.aiStub)
+        return new StubProvider();
+    if (!opts?.forceByok && aiMode() === 'cli')
+        return new CliProvider();
+    const key = getDecryptedKey(providerId);
+    if (!key)
+        throw new ProviderKeyError(providerId);
+    switch (providerId) {
+        case 'anthropic':
+            return new AnthropicProvider(key);
+        case 'openai': {
+            // OpenAI 호환 게이트웨이(LiteLLM 등) 지원: 인앱 설정 > env > 표준 OpenAI 순.
+            const base = getSetting('openai_base_url') || config.openaiBaseUrl || undefined;
+            const headers = getSetting('openai_headers') || undefined;
+            return new OpenAIProvider(key, base, headers);
+        }
+        case 'openrouter': {
+            // 게이트웨이 base 를 설정하면 openrouter 슬롯도 그 게이트웨이로 라우팅(키를 여기 넣은 경우).
+            // 안 하면 표준 openrouter.ai.
+            const base = getSetting('openai_base_url') || config.openaiBaseUrl || undefined;
+            const headers = getSetting('openai_headers') || undefined;
+            return new OpenRouterProvider(key, base, headers);
+        }
+        default:
+            throw new Error(`Unknown provider: ${providerId}`);
+    }
+}
+/** True if we can produce SOME provider (stub, managed, or a stored key). */
+export function hasUsableProvider(providerId) {
+    if (config.managedTier || config.aiStub)
+        return true;
+    if (aiMode() === 'cli')
+        return cliAvailable();
+    return getDecryptedKey(providerId) !== null;
+}

package/api/dist/providers/managed.js

@@ -0,0 +1,22 @@
+/**
+ * v2 managed-tier provider (P-03 / §5). Interface only in v1: the constructor
+ * and shape are defined so the factory can switch to it when MANAGED_TIER=true,
+ * but the implementation is intentionally not shipped. This keeps the AI-call
+ * abstraction ready for the managed cloud tier without pulling it into v1 scope.
+ */
+export class ManagedProvider {
+    id = 'managed';
+    base;
+    key;
+    constructor(base = process.env.MANAGED_API_BASE, key = process.env.MANAGED_API_KEY) {
+        this.base = base;
+        this.key = key;
+    }
+    // eslint-disable-next-line require-yield
+    async *streamChat(_params) {
+        throw new Error('ManagedProvider is not implemented in v1. Set MANAGED_TIER=false and use BYOK keys.');
+    }
+    async testConnection(_model) {
+        return { ok: false, detail: 'managed tier not implemented in v1' };
+    }
+}

package/api/dist/providers/sse.js

@@ -0,0 +1,37 @@
+/**
+ * Consume a fetch() streaming Response body and yield each SSE `data:` payload
+ * as a string. Events are separated by a blank line; multiple `data:` lines in
+ * one event are joined with '\n'. Yields the raw data text — JSON parsing is the
+ * caller's job, since payload shape differs per provider.
+ */
+export async function* iterateSse(res) {
+    if (!res.body)
+        return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            buffer = buffer.replace(/\r\n/g, '\n');
+            let idx;
+            while ((idx = buffer.indexOf('\n\n')) !== -1) {
+                const rawEvent = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+                const data = rawEvent
+                    .split('\n')
+                    .filter((l) => l.startsWith('data:'))
+                    .map((l) => l.slice(5).trimStart())
+                    .join('\n');
+                if (data)
+                    yield data;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/api/dist/providers/stub.js

@@ -0,0 +1,55 @@
+/**
+ * Deterministic, offline provider. Enabled via AI_STUB=1 or auto-selected when
+ * no BYOK key is configured for a provider. Lets the whole pipeline (interview
+ * -> streaming draft -> editor -> export) run in tests and demos with no network
+ * and no real API key. Output is derived from the prompt so it is reproducible.
+ */
+export class StubProvider {
+    id = 'stub';
+    async *streamChat(params) {
+        const userMsg = [...params.messages].reverse().find((m) => m.role === 'user');
+        const heading = extractHeading(userMsg?.content ?? '') ?? '섹션';
+        const answers = extractAnswers(userMsg?.content ?? '');
+        const lines = [];
+        lines.push(`이 섹션은 "${heading}" 에 대한 초안입니다.`);
+        lines.push('');
+        if (answers.length) {
+            lines.push('인터뷰 답변을 반영한 핵심 항목:');
+            for (const a of answers.slice(0, 4))
+                lines.push(`- ${a}`);
+        }
+        else {
+            lines.push('- 핵심 가치 제안을 명확히 한다.');
+            lines.push('- 대상 사용자와 문제를 정의한다.');
+            lines.push('- 성공 기준을 측정 가능하게 둔다.');
+        }
+        lines.push('');
+        lines.push('> (스텁 프로바이더 출력 · 실제 AI 키를 등록하면 대체됩니다.)');
+        const text = lines.join('\n');
+        // stream word/token-ish chunks so the SSE section boundaries exercise.
+        // STUB_STREAM_DELAY_MS(>0) 로 청크 사이 지연 — 데모 녹화에서 스트리밍이 보이게(기본 0).
+        const delay = Number(process.env.STUB_STREAM_DELAY_MS) || 0;
+        for (const chunk of text.match(/\S+\s*|\n/g) ?? [text]) {
+            yield chunk;
+            if (delay > 0)
+                await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    async testConnection(_model) {
+        return { ok: true, detail: 'stub provider · always ok' };
+    }
+}
+function extractHeading(prompt) {
+    const m = prompt.match(/섹션 제목[:：]\s*(.+)/) ?? prompt.match(/heading[:：]\s*(.+)/i);
+    return m ? m[1].trim() : null;
+}
+function extractAnswers(prompt) {
+    // answers are embedded as "- Q: ... / A: ..." style lines in the draft prompt
+    const out = [];
+    for (const line of prompt.split('\n')) {
+        const m = line.match(/^A[:：]\s*(.+)/);
+        if (m && m[1].trim())
+            out.push(m[1].trim());
+    }
+    return out;
+}

package/api/dist/providers/types.js

@@ -0,0 +1 @@
+export {};

package/api/dist/routes/backup.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { HttpError, parse } from "./helpers.js";
+import { backupBytes, restoreFromBytes } from "../db/index.js";
+/**
+ * 워크스페이스 백업/복원 (v0.5 데이터 안전). 전체 DB 파일을 스냅샷으로 내려받고,
+ * 검증 후 통째로 복원한다. 복원은 파괴적이므로 프론트에서 확인을 받는다.
+ */
+export async function backupRoutes(app) {
+    app.get('/api/backup', async (_req, reply) => {
+        const bytes = backupBytes();
+        reply.header('Content-Type', 'application/octet-stream');
+        reply.header('Content-Disposition', 'attachment; filename="drafting-backup.sqlite"');
+        return reply.send(bytes);
+    });
+    // 파일은 base64 로 받는다(멀티파트 의존성 회피). 라우트 한정 바디 상한 상향.
+    app.post('/api/restore', { bodyLimit: 256 * 1024 * 1024 }, async (req) => {
+        const { data } = parse(z.object({ data: z.string().min(1) }), req.body);
+        const buf = Buffer.from(data, 'base64');
+        if (buf.length < 100)
+            throw new HttpError(400, '백업 파일이 비었거나 손상되었습니다');
+        restoreFromBytes(buf);
+        return { ok: true };
+    });
+}