@hanmariyang/drafting 1.6.2

package/api/dist/index.js

@@ -0,0 +1,89 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import fastifyStatic from '@fastify/static';
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+import { config } from "./lib/config.js";
+import { getDb } from "./db/index.js";
+import { getMasterKey } from "./lib/crypto.js";
+import { loadTemplates } from "./lib/templates.js";
+import { HttpError } from "./routes/helpers.js";
+import { projectRoutes } from "./routes/projects.js";
+import { documentRoutes } from "./routes/documents.js";
+import { interviewRoutes } from "./routes/interview.js";
+import { suggestionRoutes } from "./routes/suggestions.js";
+import { deliverableRoutes } from "./routes/deliverables.js";
+import { keyRoutes } from "./routes/keys.js";
+import { settingsRoutes } from "./routes/settings.js";
+import { shareRoutes } from "./routes/share.js";
+import { backupRoutes } from "./routes/backup.js";
+export async function buildServer() {
+    // fail fast on infra: db schema applied, master key resolvable, templates loaded
+    getDb();
+    getMasterKey();
+    loadTemplates();
+    const app = Fastify({ logger: { level: process.env.LOG_LEVEL ?? 'info' } });
+    // 보안: 기본은 same-origin(교차 오리진 차단) — 무인증 로컬 API 를 악성 페이지의
+    // CSRF·데이터 유출(/api/backup 등)로부터 보호. 리버스 프록시 구성은 env 로 허용 오리진 지정.
+    await app.register(cors, {
+        origin: config.allowOrigins.length ? config.allowOrigins : false,
+    });
+    // Tolerate empty bodies on POST/PUT/DELETE that carry an application/json
+    // content-type but no payload (browsers set the header even with no body).
+    app.addContentTypeParser('application/json', { parseAs: 'string' }, (_req, body, done) => {
+        const text = body.trim();
+        if (!text)
+            return done(null, undefined);
+        try {
+            done(null, JSON.parse(text));
+        }
+        catch (err) {
+            err.statusCode = 400;
+            done(err, undefined);
+        }
+    });
+    app.setErrorHandler((err, _req, reply) => {
+        if (err instanceof HttpError) {
+            reply.code(err.status).send({ error: err.message });
+            return;
+        }
+        app.log.error(err);
+        reply.code(500).send({ error: err?.message ?? 'internal error' });
+    });
+    await app.register(projectRoutes);
+    await app.register(documentRoutes);
+    await app.register(interviewRoutes);
+    await app.register(suggestionRoutes);
+    await app.register(deliverableRoutes);
+    await app.register(keyRoutes);
+    await app.register(settingsRoutes);
+    await app.register(shareRoutes);
+    await app.register(backupRoutes);
+    app.get('/api/health', async () => ({ ok: true, version: config.version }));
+    // serve the built SPA in production (dev uses the vite server)
+    if (fs.existsSync(config.webDist)) {
+        await app.register(fastifyStatic, { root: config.webDist, wildcard: false });
+        app.setNotFoundHandler((req, reply) => {
+            if (req.url.startsWith('/api') || req.url.startsWith('/s/')) {
+                reply.code(404).send({ error: 'not found' });
+                return;
+            }
+            reply.type('text/html').send(fs.readFileSync(path.join(config.webDist, 'index.html')));
+        });
+    }
+    return app;
+}
+// only start when run directly (tests import buildServer without listening)
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+    const app = await buildServer();
+    try {
+        await app.listen({ port: config.port, host: config.host });
+        app.log.info(`Drafting listening on http://${config.host}:${config.port}`);
+    }
+    catch (err) {
+        app.log.error(err);
+        process.exit(1);
+    }
+}

package/api/dist/lib/ai.js

@@ -0,0 +1,314 @@
+import { resolveProvider } from "../providers/index.js";
+import { getTemplateForType } from "./templates.js";
+import { getSetting } from "../db/repos.js";
+import * as repo from "../db/repos.js";
+const DEFAULT_MODELS = {
+    anthropic: 'claude-sonnet-4-6',
+    openai: 'gpt-4o-mini',
+    // 3.5-sonnet 은 OpenRouter 에서 deprecated(404) — 활성 4.x 최신으로.
+    openrouter: 'anthropic/claude-sonnet-4.6',
+};
+const PROVIDER_ORDER = ['openrouter', 'anthropic', 'openai'];
+function pickDefaultProvider() {
+    for (const p of PROVIDER_ORDER) {
+        if (repo.getKeyMeta(p))
+            return p;
+    }
+    return 'openrouter';
+}
+/** Per-document-type model + token budget (SPEC-18/19). Settings override defaults. */
+export function getModelConfig(docType) {
+    const stored = getSetting('provider_models') ?? {};
+    const base = {
+        provider: pickDefaultProvider(),
+        model: '',
+        // 추론형(reasoning) 모델은 추론 토큰이 예산을 먹어 본문이 비기 쉽다 — 헤드룸 확보.
+        maxTokens: 8192,
+    };
+    const merged = { ...base, ...(stored.default ?? {}), ...(stored[docType] ?? {}) };
+    if (!merged.provider)
+        merged.provider = base.provider;
+    // 모델 미지정 시: 게이트웨이가 설정돼 있으면 그 게이트웨이가 제공하는 첫 모델을 기본값으로
+    // (하드코딩 claude 기본값은 게이트웨이 키가 접근 못 해 거부되는 전형을 방지).
+    if (!merged.model)
+        merged.model = gatewayDefaultModel(merged.provider) ?? DEFAULT_MODELS[merged.provider];
+    if (!merged.maxTokens)
+        merged.maxTokens = 8192;
+    return merged;
+}
+/** 게이트웨이(openai_base_url) 가 설정된 openai/openrouter 면 그 게이트웨이의 첫 모델을 반환. */
+function gatewayDefaultModel(provider) {
+    if (provider !== 'openai' && provider !== 'openrouter')
+        return null;
+    const base = getSetting('openai_base_url') || '';
+    if (!base)
+        return null; // 표준 provider — 하드코딩 기본 모델 유지
+    const models = getSetting('openai_models') ?? [];
+    return models.length ? models[0] : null;
+}
+// ── prompt construction ──────────────────────────────────────────────────────
+function parentContextBlock(documentId) {
+    const ctx = repo.getParentContext(documentId);
+    if (!ctx)
+        return '';
+    const body = ctx.sections
+        .map((s) => `### ${s.heading}\n${s.body}`)
+        .join('\n\n');
+    return (`상위 문서 컨텍스트 (${ctx.parentType}, "${ctx.parentTitle}", v${ctx.parentVersion}) — ` +
+        `이 내용과 정합하도록 작성하라:\n\n${body}\n\n---\n`);
+}
+function answersBlock(answers) {
+    if (!answers.length)
+        return '(인터뷰 답변 없음 — 합리적 기본값으로 작성)';
+    return answers.map((a) => `Q: ${a.question}\nA: ${a.answer}`).join('\n\n');
+}
+/** Short human basis label for a suggestion (SYSTEM.md §0.3). */
+export function draftSourceLabel(answers) {
+    if (!answers.length)
+        return '인터뷰 (기본값)';
+    const ids = answers
+        .map((a) => a.questionId)
+        .filter(Boolean)
+        .slice(0, 4);
+    return ids.length ? `인터뷰 ${ids.join('·')}` : '인터뷰';
+}
+/** Messages to draft one section. Section-by-section keeps SSE boundaries clean. */
+export function buildSectionMessages(params) {
+    const parent = parentContextBlock(params.documentId);
+    // 문서 전체 섹션 구성을 알려줘야 섹션 간 내용 중복(개요에 문제 정의 통째 포함 등)이 없다
+    const allSections = getTemplateForType(params.docType)?.sections ?? [];
+    const outline = allSections.length
+        ? `이 문서의 전체 섹션 구성: ${allSections.map((s) => `"${s}"`).join(' · ')}. ` +
+            `너는 그중 "${params.heading}" 하나만 쓴다. 다른 섹션에서 다룰 내용은 이 섹션에서 반복하거나 미리 쓰지 말라. `
+        : '';
+    const system = `${params.guidance}\n\n` +
+        `너는 지금 "${params.docType}" 문서의 한 섹션만 작성한다. ` +
+        outline +
+        `섹션 제목("${params.heading}")은 앱이 별도로 표시하므로 본문에 다시 쓰지 말라. ` +
+        `제목이나 다른 섹션은 쓰지 말고, 요청된 섹션 본문만 마크다운으로 출력하라. ` +
+        `간결하고 구체적으로, 불릿과 짧은 문단을 섞어 작성하라.`;
+    const user = `${parent}` +
+        `아래는 기획 인터뷰 답변이다:\n\n${answersBlock(params.answers)}\n\n` +
+        `이제 다음 섹션을 작성하라.\n섹션 제목: ${params.heading}\n`;
+    return [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+    ];
+}
+/**
+ * 모델이 프롬프트 지시를 어기고 본문 첫 줄에 섹션 제목을 반복하는 경우가 있다
+ * ("## 문제 정의" / "**문제 정의**" / "문제 정의:" 등). 앱이 heading 을 별도
+ * 렌더하므로 저장 전에 걷어낸다. 제목과 일치할 때만 — 일반 본문은 건드리지 않는다.
+ */
+export function stripLeadingHeading(body, heading) {
+    const trimmed = body.trim();
+    const nl = trimmed.indexOf('\n');
+    const first = (nl === -1 ? trimmed : trimmed.slice(0, nl)).trim();
+    const normalize = (s) => s
+        .replace(/^#{1,6}\s*/, '') // 마크다운 heading 마커
+        .replace(/^\*\*(.*)\*\*$/, '$1') // 볼드 감싸기
+        .replace(/[\s:：.]+$/, '') // 꼬리 콜론·마침표
+        .trim();
+    if (normalize(first) !== normalize(heading))
+        return trimmed;
+    return nl === -1 ? '' : trimmed.slice(nl + 1).trim();
+}
+/**
+ * Generate a full document draft, section by section. Creates empty sections
+ * up-front (so each has a stable id the client can target), then streams each
+ * one. Emits SSE-shaped events per docs/spec/ux-mode-transition.md §3.
+ */
+export async function* streamDocumentDraft(documentId, signal) {
+    const doc = repo.getDocument(documentId);
+    if (!doc) {
+        yield { type: 'error', message: 'document not found' };
+        return;
+    }
+    const template = getTemplateForType(doc.type);
+    const headings = template?.sections ?? ['개요'];
+    const session = repo.getSessionByDocument(documentId);
+    const answers = session?.answers ?? [];
+    const guidance = template?.draftGuidance ?? '명확한 기획 문서를 작성한다.';
+    const cfg = getModelConfig(doc.type);
+    const provider = resolveProvider(cfg.provider);
+    repo.setDocumentStatus(documentId, 'streaming');
+    // AI output is always a PROPOSAL (SYSTEM.md §0.1). Create empty sections
+    // up-front (stable ids for the client) in 'proposed' state.
+    const created = repo.replaceSections(documentId, headings.map((h) => ({ heading: h, body: '' })), 'proposed');
+    // Basis for the whole draft = the interview answers behind it (§0.3).
+    const draftSource = draftSourceLabel(answers);
+    try {
+        for (let i = 0; i < created.length; i++) {
+            const section = created[i];
+            yield {
+                type: 'section_start',
+                sectionId: section.id,
+                heading: section.heading,
+                index: i,
+                total: created.length,
+            };
+            const messages = buildSectionMessages({
+                documentId,
+                docType: doc.type,
+                heading: section.heading,
+                answers,
+                guidance,
+            });
+            let body = '';
+            for await (const delta of provider.streamChat({
+                model: cfg.model,
+                maxTokens: cfg.maxTokens,
+                messages,
+                signal,
+            })) {
+                body += delta;
+                yield { type: 'token', sectionId: section.id, delta };
+            }
+            const finalBody = stripLeadingHeading(body, section.heading);
+            repo.updateSection(section.id, { body: finalBody });
+            // Each generated section arrives as an 'add' proposal with its basis.
+            repo.createSuggestion({
+                documentId,
+                sectionId: section.id,
+                kind: 'add',
+                title: `"${section.heading}" 섹션 초안`,
+                body: '인터뷰 답변을 바탕으로 생성된 초안입니다. 수락하면 문서에 반영됩니다.',
+                quoteAfter: finalBody,
+                source: draftSource,
+            });
+            yield { type: 'section_end', sectionId: section.id };
+        }
+        repo.setDocumentStatus(documentId, 'ready');
+        repo.snapshotDocument(documentId, 'save', { reason: 'initial_draft' });
+        yield { type: 'done', documentId };
+    }
+    catch (e) {
+        repo.setDocumentStatus(documentId, 'draft');
+        yield { type: 'error', message: e.message };
+    }
+}
+/**
+ * Rewrite one section from an explicit user instruction (SYSTEM.md §0.4, the
+ * 3rd handling option). Non-streaming: runs the provider to completion, sets the
+ * section back to 'proposed', and returns a NEW 'revise' suggestion whose source
+ * is the user's own instruction. Works with the stub provider (no network).
+ */
+export async function rewriteSection(sectionId, instruction) {
+    const section = repo.getSection(sectionId);
+    if (!section)
+        return null;
+    const doc = repo.getDocument(section.document_id);
+    if (!doc)
+        return null;
+    const template = getTemplateForType(doc.type);
+    const session = repo.getSessionByDocument(doc.id);
+    const answers = session?.answers ?? [];
+    const guidance = template?.draftGuidance ?? '명확한 기획 문서를 작성한다.';
+    const cfg = getModelConfig(doc.type);
+    const provider = resolveProvider(cfg.provider);
+    const messages = buildSectionMessages({
+        documentId: doc.id,
+        docType: doc.type,
+        heading: section.heading,
+        answers,
+        guidance,
+    });
+    // append the user's rewrite instruction + the current text as context
+    messages.push({
+        role: 'user',
+        content: `현재 "${section.heading}" 섹션 본문:\n\n${section.body}\n\n` +
+            `아래 지시에 따라 이 섹션을 다시 써라. 섹션 본문만 마크다운으로 출력하라.\n` +
+            `지시: ${instruction}`,
+    });
+    const before = section.body;
+    let body = '';
+    for await (const delta of provider.streamChat({
+        model: cfg.model,
+        maxTokens: cfg.maxTokens,
+        messages,
+    })) {
+        body += delta;
+    }
+    const next = stripLeadingHeading(body, section.heading);
+    repo.updateSection(section.id, { body: next });
+    repo.setSectionStatus(section.id, 'proposed');
+    repo.snapshotDocument(doc.id, 'save', { reason: 'rewrite_section', sectionId });
+    const trimmed = instruction.trim();
+    const suggestion = repo.createSuggestion({
+        documentId: doc.id,
+        sectionId: section.id,
+        kind: 'revise',
+        title: `"${section.heading}" 고쳐쓰기`,
+        body: '사용자 지시로 재작성했습니다. 수락하면 문서에 반영됩니다.',
+        quoteBefore: before,
+        quoteAfter: next,
+        source: `사용자 지시: ${trimmed.length > 60 ? trimmed.slice(0, 60) + '…' : trimmed}`,
+    });
+    return { section: repo.getSection(section.id), suggestion };
+}
+/** Regenerate a single section (SPEC-07) — only this section is replaced. */
+export async function* streamSectionRegeneration(sectionId, signal) {
+    const section = repo.getSection(sectionId);
+    if (!section) {
+        yield { type: 'error', message: 'section not found' };
+        return;
+    }
+    const doc = repo.getDocument(section.document_id);
+    if (!doc) {
+        yield { type: 'error', message: 'document not found' };
+        return;
+    }
+    const template = getTemplateForType(doc.type);
+    const session = repo.getSessionByDocument(doc.id);
+    const answers = session?.answers ?? [];
+    const guidance = template?.draftGuidance ?? '명확한 기획 문서를 작성한다.';
+    const cfg = getModelConfig(doc.type);
+    const provider = resolveProvider(cfg.provider);
+    const before = section.body;
+    yield {
+        type: 'section_start',
+        sectionId: section.id,
+        heading: section.heading,
+        index: 0,
+        total: 1,
+    };
+    try {
+        const messages = buildSectionMessages({
+            documentId: doc.id,
+            docType: doc.type,
+            heading: section.heading,
+            answers,
+            guidance,
+        });
+        let body = '';
+        for await (const delta of provider.streamChat({
+            model: cfg.model,
+            maxTokens: cfg.maxTokens,
+            messages,
+            signal,
+        })) {
+            body += delta;
+            yield { type: 'token', sectionId: section.id, delta };
+        }
+        // Regenerated content is a fresh PROPOSAL — back to 'proposed' until re-accepted.
+        const finalBody = stripLeadingHeading(body, section.heading);
+        repo.updateSection(section.id, { body: finalBody });
+        repo.setSectionStatus(section.id, 'proposed');
+        repo.createSuggestion({
+            documentId: doc.id,
+            sectionId: section.id,
+            kind: 'revise',
+            title: `"${section.heading}" 섹션 재생성`,
+            body: '섹션을 재생성했습니다. 수락하면 새 본문이 문서에 반영됩니다.',
+            quoteBefore: before,
+            quoteAfter: finalBody,
+            source: draftSourceLabel(answers),
+        });
+        yield { type: 'section_end', sectionId: section.id };
+        repo.snapshotDocument(doc.id, 'save', { reason: 'regenerate_section', sectionId });
+        yield { type: 'done', documentId: doc.id };
+    }
+    catch (e) {
+        yield { type: 'error', message: e.message };
+    }
+}

package/api/dist/lib/config.js

@@ -0,0 +1,57 @@
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+import path from 'node:path';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Find the repo root by walking up until we see db/schema.sql. Works whether the
+ * code runs from api/src/lib (dev/tests, .ts) or api/dist/lib (prod build, .js).
+ */
+function findRepoRoot(start) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, 'db', 'schema.sql')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // fallback: assume three levels up from api/src|dist/lib
+    return path.resolve(start, '..', '..', '..');
+}
+export const REPO_ROOT = process.env.DRAFTING_ROOT ?? findRepoRoot(__dirname);
+function bool(v) {
+    return v === '1' || v === 'true' || v === 'yes';
+}
+/** 앱 버전은 루트 package.json 의 단일 소스에서 읽는다 (하드코딩 금지 — 릴리스마다 어긋남). */
+function readVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const config = {
+    port: Number(process.env.PORT ?? 8080),
+    host: process.env.HOST ?? '0.0.0.0',
+    databasePath: process.env.DATABASE_PATH ?? path.join(REPO_ROOT, 'data', 'drafting.sqlite'),
+    encryptionKey: process.env.APP_ENCRYPTION_KEY ?? '',
+    managedTier: bool(process.env.MANAGED_TIER),
+    aiStub: bool(process.env.AI_STUB),
+    schemaPath: path.join(REPO_ROOT, 'db', 'schema.sql'),
+    templatesDir: path.join(REPO_ROOT, 'api', 'templates'),
+    webDist: path.join(REPO_ROOT, 'web', 'dist'),
+    version: readVersion(),
+    // OpenAI 호환 게이트웨이(LiteLLM·Azure·사내 프록시 등) base URL 오버라이드.
+    // 비워두면 표준 OpenAI. 회사 게이트웨이 주소는 여기(env/설정)에만 두고 코드엔 넣지 않는다.
+    openaiBaseUrl: (process.env.OPENAI_BASE_URL ?? process.env.LITELLM_BASE_URL ?? '').trim(),
+    // CORS 는 기본 same-origin 만(웹 UI 를 api 가 같은 오리진으로 서빙, dev 는 vite 프록시).
+    // 다른 오리진에서 프론트를 띄우는 리버스 프록시 구성만 여기에 허용 오리진을 명시한다.
+    // 이 값을 비워두면 브라우저의 교차 오리진 요청이 차단돼 로컬 API 가 CSRF·유출로부터 보호된다.
+    allowOrigins: (process.env.DRAFTING_ALLOW_ORIGINS ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean),
+};

package/api/dist/lib/crypto.js

@@ -0,0 +1,71 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from "./config.js";
+// AES-256-GCM at-rest encryption for BYOK provider keys (G-01: never plaintext).
+const ALGO = 'aes-256-gcm';
+let cachedKey = null;
+/**
+ * Resolve the 32-byte master key. Priority:
+ *   1. APP_ENCRYPTION_KEY env (base64 or hex decoding to exactly 32 bytes)
+ *   2. Persisted data/master.key (generated on first boot, chmod 600)
+ * Generating-and-persisting keeps a fresh install zero-config while still
+ * surviving restarts. Set APP_ENCRYPTION_KEY in prod so keys survive a wipe.
+ */
+export function getMasterKey() {
+    if (cachedKey)
+        return cachedKey;
+    const fromEnv = config.encryptionKey.trim();
+    if (fromEnv) {
+        const buf = decodeKey(fromEnv);
+        if (buf.length !== 32) {
+            throw new Error(`APP_ENCRYPTION_KEY must decode to 32 bytes (got ${buf.length}). ` +
+                `Generate: node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"`);
+        }
+        cachedKey = buf;
+        return buf;
+    }
+    const keyFile = path.join(path.dirname(config.databasePath), 'master.key');
+    if (fs.existsSync(keyFile)) {
+        cachedKey = decodeKey(fs.readFileSync(keyFile, 'utf8').trim());
+        return cachedKey;
+    }
+    const generated = crypto.randomBytes(32);
+    fs.mkdirSync(path.dirname(keyFile), { recursive: true });
+    fs.writeFileSync(keyFile, generated.toString('base64'), { mode: 0o600 });
+    fs.chmodSync(keyFile, 0o600);
+    cachedKey = generated;
+    return generated;
+}
+function decodeKey(s) {
+    // try base64 then hex
+    if (/^[0-9a-fA-F]{64}$/.test(s))
+        return Buffer.from(s, 'hex');
+    return Buffer.from(s, 'base64');
+}
+export function seal(plaintext) {
+    const key = getMasterKey();
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv(ALGO, key, iv);
+    const ct = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return {
+        ciphertext: ct.toString('base64'),
+        iv: iv.toString('base64'),
+        authTag: authTag.toString('base64'),
+    };
+}
+export function open(sealed) {
+    const key = getMasterKey();
+    const decipher = crypto.createDecipheriv(ALGO, key, Buffer.from(sealed.iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(sealed.authTag, 'base64'));
+    const pt = Buffer.concat([
+        decipher.update(Buffer.from(sealed.ciphertext, 'base64')),
+        decipher.final(),
+    ]);
+    return pt.toString('utf8');
+}
+/** Reset cached key — test-only. */
+export function _resetKeyCache() {
+    cachedKey = null;
+}