careermate 0.1.0

package/apps/web/src/exports.ts

@@ -0,0 +1,68 @@
+/**
+ * Thin adapter over @careermate/exporters. Single integration point so the route
+ * layer doesn't depend on the exporter package's internal shape. Resolves the
+ * records a given export needs and returns a ready-to-download payload.
+ */
+import {
+  coverLetterToMarkdown,
+  coverLetterToHtml,
+  resumeToMarkdown,
+  profileToMarkdown,
+  interviewPrepToMarkdown,
+  type ExportResult,
+} from '@careermate/exporters';
+import {
+  coverLetterRepo,
+  documentRepo,
+  jobRepo,
+  profileRepo,
+  experienceRepo,
+  projectRepo,
+  skillRepo,
+  interviewRepo,
+} from '@careermate/db';
+import { HttpError } from './http.ts';
+
+export type ExportFormat = 'md' | 'html' | 'txt';
+
+function asFormat(result: ExportResult, format: ExportFormat): ExportResult {
+  if (format === 'txt') {
+    // Markdown is already readable as plain text; just relabel.
+    return {
+      filename: result.filename.replace(/\.(md|html)$/i, '.txt'),
+      mimeType: 'text/plain; charset=utf-8',
+      content: result.content,
+    };
+  }
+  return result;
+}
+
+export function exportCoverLetter(id: string, format: ExportFormat): ExportResult {
+  const cl = coverLetterRepo.get(id, true);
+  if (!cl) throw new HttpError(404, '자기소개서를 찾을 수 없습니다.');
+  const job = cl.job_id ? jobRepo.get(cl.job_id) : null;
+  const profile = profileRepo.get();
+  if (format === 'html') return coverLetterToHtml(cl, { job, profile });
+  return asFormat(coverLetterToMarkdown(cl, { job, profile }), format);
+}
+
+export function exportDocument(id: string, format: ExportFormat): ExportResult {
+  const doc = documentRepo.get(id);
+  if (!doc) throw new HttpError(404, '문서를 찾을 수 없습니다.');
+  return asFormat(resumeToMarkdown(doc, profileRepo.get()), format);
+}
+
+export function exportProfile(format: ExportFormat): ExportResult {
+  const profile = profileRepo.get();
+  if (!profile) throw new HttpError(404, '프로필이 없습니다.');
+  return asFormat(
+    profileToMarkdown(profile, experienceRepo.list(), projectRepo.list(), skillRepo.list()),
+    format,
+  );
+}
+
+export function exportInterview(jobId: string, format: ExportFormat): ExportResult {
+  const prep = interviewRepo.getByJob(jobId);
+  if (!prep) throw new HttpError(404, '면접 준비 자료가 없습니다.');
+  return asFormat(interviewPrepToMarkdown(prep, jobRepo.get(jobId)), format);
+}

package/apps/web/src/http.ts

@@ -0,0 +1,180 @@
+/**
+ * Minimal HTTP plumbing built on node:http — a tiny router, JSON helpers,
+ * size-limited body parsing, and path-traversal-safe static file serving.
+ * Kept dependency-free so installation is a single `npm install`.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ZodError, type ZodType } from 'zod';
+
+export interface Ctx {
+  req: IncomingMessage;
+  res: ServerResponse;
+  params: Record<string, string>;
+  query: URLSearchParams;
+  url: URL;
+}
+
+export type Handler = (ctx: Ctx) => unknown | Promise<unknown>;
+
+interface Route {
+  method: string;
+  pattern: RegExp;
+  keys: string[];
+  handler: Handler;
+}
+
+const MAX_BODY = 8 * 1024 * 1024; // 8 MB — generous for pasted résumés, bounded against abuse.
+
+export class Router {
+  private routes: Route[] = [];
+
+  add(method: string, path: string, handler: Handler): this {
+    const keys: string[] = [];
+    const pattern = new RegExp(
+      '^' +
+        path.replace(/:[^/]+/g, (m) => {
+          keys.push(m.slice(1));
+          return '([^/]+)';
+        }) +
+        '/?$',
+    );
+    this.routes.push({ method: method.toUpperCase(), pattern, keys, handler });
+    return this;
+  }
+
+  get(p: string, h: Handler) { return this.add('GET', p, h); }
+  post(p: string, h: Handler) { return this.add('POST', p, h); }
+  put(p: string, h: Handler) { return this.add('PUT', p, h); }
+  patch(p: string, h: Handler) { return this.add('PATCH', p, h); }
+  delete(p: string, h: Handler) { return this.add('DELETE', p, h); }
+
+  match(method: string, pathname: string): { handler: Handler; params: Record<string, string> } | null {
+    for (const r of this.routes) {
+      if (r.method !== method) continue;
+      const m = r.pattern.exec(pathname);
+      if (!m) continue;
+      const params: Record<string, string> = {};
+      r.keys.forEach((k, i) => (params[k] = decodeURIComponent(m[i + 1]!)));
+      return { handler: r.handler, params };
+    }
+    return null;
+  }
+}
+
+/* ----------------------------------------------------------- response helpers */
+
+export function sendJson(res: ServerResponse, status: number, data: unknown): void {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+  });
+  res.end(body);
+}
+
+export function sendDownload(res: ServerResponse, filename: string, mimeType: string, content: string): void {
+  const safe = filename.replace(/[^\w.\-가-힣 ]/g, '_');
+  res.writeHead(200, {
+    'Content-Type': mimeType,
+    'Content-Disposition': `attachment; filename*=UTF-8''${encodeURIComponent(safe)}`,
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+  });
+  res.end(content);
+}
+
+/** Thrown by handlers to produce a clean error response. */
+export class HttpError extends Error {
+  constructor(public status: number, message: string, public code?: string) {
+    super(message);
+  }
+}
+
+export async function readJsonBody<T>(req: IncomingMessage, schema?: ZodType<T>): Promise<T> {
+  const raw = await readBody(req);
+  if (!raw) return (schema ? schema.parse({}) : {}) as T;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new HttpError(400, '잘못된 JSON 형식입니다.', 'bad_json');
+  }
+  if (!schema) return parsed as T;
+  try {
+    return schema.parse(parsed);
+  } catch (e) {
+    if (e instanceof ZodError) {
+      const msg = e.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ');
+      throw new HttpError(400, `입력값 검증 실패 — ${msg}`, 'validation');
+    }
+    throw e;
+  }
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks: Buffer[] = [];
+    req.on('data', (c: Buffer) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(new HttpError(413, '요청 본문이 너무 큽니다.', 'too_large'));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}
+
+/* -------------------------------------------------------------- static files */
+
+const MIME: Record<string, string> = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.ico': 'image/x-icon',
+  '.woff2': 'font/woff2',
+  '.map': 'application/json',
+};
+
+/**
+ * Serve a file from `root`, refusing any path that escapes it. Returns false if
+ * not found so the caller can fall back (e.g. SPA index).
+ */
+export function serveStatic(
+  res: ServerResponse,
+  root: string,
+  relPath: string,
+  transform?: (html: string) => string,
+): boolean {
+  const cleaned = decodeURIComponent(relPath).replace(/\0/g, '');
+  const resolved = path.resolve(root, '.' + path.posix.normalize('/' + cleaned));
+  // Path-traversal guard: resolved file must stay within root.
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+    res.writeHead(403).end('Forbidden');
+    return true;
+  }
+  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) return false;
+  const ext = path.extname(resolved).toLowerCase();
+  const mime = MIME[ext] ?? 'application/octet-stream';
+  let payload: Buffer | string = fs.readFileSync(resolved);
+  if (transform && (ext === '.html')) payload = transform(payload.toString('utf8'));
+  res.writeHead(200, {
+    'Content-Type': mime,
+    'X-Content-Type-Options': 'nosniff',
+    'Cache-Control': ext === '.html' ? 'no-store' : 'no-cache',
+  });
+  res.end(payload);
+  return true;
+}

package/apps/web/src/index.ts

@@ -0,0 +1,49 @@
+/**
+ * CareerMate local app entry point.
+ *
+ *   npm start   →   starts the dashboard at http://127.0.0.1:<port> and opens
+ *                   your browser. The MCP server (apps/mcp) is launched
+ *                   separately by your AI client and shares the same database.
+ */
+import { spawn } from 'node:child_process';
+import { startServer } from './server.ts';
+import { getDataDir } from '@careermate/db';
+import { APP_VERSION } from './info.ts';
+
+const DEFAULT_PORT = Number(process.env.CAREERMATE_PORT ?? 4319);
+
+function openBrowser(url: string): void {
+  if (process.env.CAREERMATE_NO_OPEN === '1') return;
+  const platform = process.platform;
+  try {
+    if (platform === 'win32') {
+      spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
+    } else if (platform === 'darwin') {
+      spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+    } else {
+      spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+    }
+  } catch {
+    /* opening the browser is best-effort */
+  }
+}
+
+async function main(): Promise<void> {
+  const { url } = await startServer(DEFAULT_PORT);
+  const line = '─'.repeat(54);
+  console.log(`\n┌${line}┐`);
+  console.log(`  CareerMate v${APP_VERSION} — 내 커리어 흐름 관리 도구`);
+  console.log(`${' '.repeat(2)}${'┄'.repeat(52)}`);
+  console.log(`  대시보드   ${url}`);
+  console.log(`  설치 안내   ${url}/install`);
+  console.log(`  데이터 위치 ${getDataDir()}`);
+  console.log(`  (모든 데이터는 이 컴퓨터에만 저장됩니다)`);
+  console.log(`└${line}┘\n`);
+  console.log(`종료하려면 Ctrl+C 를 누르세요.`);
+  openBrowser(url);
+}
+
+main().catch((err) => {
+  console.error('CareerMate 시작 실패:', err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/apps/web/src/info.ts

@@ -0,0 +1,50 @@
+/**
+ * Server + environment metadata surfaced to the Settings page and the /api/health
+ * endpoint. Lets non-technical users *see* where their data lives, which is a
+ * core privacy promise: everything is on this machine.
+ */
+import { getDataDir, getDbPath, getExportsDir, getBackupsDir } from '@careermate/db';
+import {
+  profileRepo,
+  experienceRepo,
+  projectRepo,
+  skillRepo,
+  documentRepo,
+  coverLetterRepo,
+  jobRepo,
+  applicationRepo,
+  interviewRepo,
+} from '@careermate/db';
+
+export const APP_NAME = 'CareerMate';
+export const APP_VERSION = '0.1.0';
+
+let _port = 0;
+export function setServerPort(port: number): void {
+  _port = port;
+}
+
+export function getServerInfo() {
+  return {
+    name: APP_NAME,
+    version: APP_VERSION,
+    port: _port,
+    url: `http://127.0.0.1:${_port}`,
+    data_dir: getDataDir(),
+    db_path: getDbPath(),
+    exports_dir: getExportsDir(),
+    backups_dir: getBackupsDir(),
+    node_version: process.version,
+    counts: {
+      profile: profileRepo.get() ? 1 : 0,
+      experiences: experienceRepo.list().length,
+      projects: projectRepo.list().length,
+      skills: skillRepo.list().length,
+      documents: documentRepo.list().length,
+      cover_letters: coverLetterRepo.list().length,
+      jobs: jobRepo.list().length,
+      applications: applicationRepo.list().length,
+      interview_preps: interviewRepo.list().length,
+    },
+  };
+}