@usercase/mcp 0.0.0-stage → 0.2.1-next.0

package/src/browser/real-chrome.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * 로그인 창을 **PC 에 깔린 일반 크롬**으로 띄운다.
+ *
+ * Playwright 가 띄운 브라우저는 자동화 표시가 있어서 구글 로그인이 막힌다 — 이메일을 넣어도 다음이 안 눌린다
+ * (10/14 bluetags Google 로그인). 그래서 크롬을 자동화 없이 실행하고, 디버깅 포트로 **쿠키만** 읽어 온다.
+ *
+ * - 빈 프로필(--user-data-dir 임시 폴더)로 연다. 사용자가 평소 쓰는 크롬은 건드리지도 보지도 않는다
+ * - 로그인하는 동안 크롬에는 아무것도 붙지 않는다 — 로그인 화면이 눈치챌 게 없다
+ * - 저장하는 건 그 사이트 쿠키뿐이다. 사용자의 구글 쿠키 같은 건 버린다
+ *
+ * 크롬(또는 엣지)이 없으면 null — 부르는 쪽이 Playwright 창으로 돌아간다.
+ * 의존성 없음. Node 22 의 WebSocket 을 쓴다.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function findChrome() {
+  const env = process.env;
+  const win = [env.PROGRAMFILES, env["PROGRAMFILES(X86)"], env.LOCALAPPDATA].filter(Boolean);
+  const candidates =
+    process.platform === "win32"
+      ? [
+          ...win.map((d) => path.join(d, "Google", "Chrome", "Application", "chrome.exe")),
+          ...win.map((d) => path.join(d, "Microsoft", "Edge", "Application", "msedge.exe")),
+        ]
+      : process.platform === "darwin"
+        ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"]
+        : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/usr/bin/microsoft-edge"];
+  return candidates.find((p) => {
+    try {
+      return fs.statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  }) || null;
+}
+
+/** 브라우저 단위 CDP 연결. 페이지에는 붙지 않는다 */
+async function connect(wsUrl) {
+  const ws = new WebSocket(wsUrl);
+  await new Promise((ok, bad) => {
+    ws.onopen = ok;
+    ws.onerror = () => bad(new Error("could not connect to Chrome"));
+  });
+  let seq = 0;
+  const waiting = new Map();
+  ws.onmessage = (ev) => {
+    const m = JSON.parse(typeof ev.data === "string" ? ev.data : ev.data.toString());
+    if (m.id && waiting.has(m.id)) {
+      const { ok, bad } = waiting.get(m.id);
+      waiting.delete(m.id);
+      m.error ? bad(new Error(m.error.message)) : ok(m.result);
+    }
+  };
+  const send = (method, params = {}, sessionId) =>
+    new Promise((ok, bad) => {
+      const id = ++seq;
+      waiting.set(id, { ok, bad });
+      ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+      setTimeout(() => waiting.has(id) && (waiting.delete(id), bad(new Error(`${method} timed out`))), 5000);
+    });
+  return { send, close: () => ws.close() };
+}
+
+/** 사이트 쿠키인가 — 같은 호스트, 그 상위 도메인(.example.com), 그 하위 도메인(auth.example.com) */
+function siteCookie(c, host) {
+  const d = String(c.domain || "").replace(/^\./, "");
+  const bare = host.replace(/^www\./, "");
+  return d === host || host.endsWith("." + d) || d === bare || d.endsWith("." + bare);
+}
+
+/** CDP 쿠키 → Playwright storageState 쿠키 */
+function toState(c) {
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path || "/",
+    expires: c.session || !(c.expires > 0) ? -1 : c.expires,
+    httpOnly: !!c.httpOnly,
+    secure: !!c.secure,
+    sameSite: ["Strict", "Lax", "None"].includes(c.sameSite) ? c.sameSite : "Lax",
+  };
+}
+
+const PROFILE_PREFIX = "earningbirds-login-";
+
+/** 사용자가 X 를 누른 것처럼 끈다. 윈도는 taskkill(/F 없이)이 창에 닫기를 보낸다, 나머지는 SIGTERM */
+function closeGently(child) {
+  try {
+    if (process.platform === "win32") spawn("taskkill", ["/PID", String(child.pid)], { stdio: "ignore" });
+    else child.kill("SIGTERM");
+  } catch {}
+}
+
+/** 임시 프로필을 지운다. 크롬이 놓을 때까지 30초 동안 다시 해 본다 */
+async function removeProfile(dir) {
+  for (let i = 0; i < 30; i++) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+      if (!fs.existsSync(dir)) return true;
+    } catch {}
+    await sleep(1000);
+  }
+  return false;
+}
+
+/** 전에 못 지운 임시 프로필(중간에 꺼졌을 때)을 치운다. 15분 넘은 것만 — 지금 열린 창의 것은 두고 */
+function sweepProfiles() {
+  try {
+    for (const name of fs.readdirSync(os.tmpdir())) {
+      if (!name.startsWith(PROFILE_PREFIX)) continue;
+      const p = path.join(os.tmpdir(), name);
+      try {
+        if (Date.now() - fs.statSync(p).mtimeMs > 15 * 60 * 1000) fs.rmSync(p, { recursive: true, force: true });
+      } catch {}
+    }
+  } catch {}
+}
+
+/** 프로필 폴더의 DevToolsActivePort 에서 크롬이 고른 포트를 읽는다 */
+async function waitPort(dir, isGone) {
+  for (let i = 0; i < 75 && !isGone(); i++) {
+    await sleep(200);
+    try {
+      const port = Number(fs.readFileSync(path.join(dir, "DevToolsActivePort"), "utf8").split("\n")[0]);
+      if (port) return port;
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * 로그인이 끝난 프로필을 화면 없이 다시 켜서 그 사이트 쿠키와 localStorage 를 읽는다.
+ * 쿠키는 크롬이 직접 풀어 준다 — 디스크의 쿠키 파일은 암호화돼 있어 밖에서 못 읽는다
+ */
+async function readProfile(exe, dir, origin) {
+  const host = new URL(origin).hostname;
+  const child = spawn(exe, ["--headless=new", "--remote-debugging-port=0", "--no-first-run", "--no-default-browser-check", `--user-data-dir=${dir}`], { stdio: "ignore" });
+  let gone = false;
+  child.on("exit", () => (gone = true));
+  child.on("error", () => (gone = true));
+  try {
+    try {
+      fs.unlinkSync(path.join(dir, "DevToolsActivePort"));
+    } catch {}
+    const port = await waitPort(dir, () => gone);
+    if (!port) return null;
+    const ver = await fetch(`http://127.0.0.1:${port}/json/version`).then((r) => r.json());
+    const cdp = await connect(ver.webSocketDebuggerUrl);
+    try {
+      const all = (await cdp.send("Storage.getCookies")).cookies || [];
+      const cookies = all.filter((c) => siteCookie(c, host)).map(toState);
+      // localStorage 는 그 사이트 화면을 하나 열어 읽는다
+      let storage = null;
+      try {
+        const { targetId } = await cdp.send("Target.createTarget", { url: origin + "/" });
+        const { sessionId } = await cdp.send("Target.attachToTarget", { targetId, flatten: true });
+        // 개발 서버는 첫 화면이 느리다. 그 사이트에 닿을 때까지 본다(최대 20초)
+        const expression = `document.readyState !== "loading" && location.origin === ${JSON.stringify(origin)} ? JSON.stringify(Object.entries(localStorage)) : ""`;
+        for (let i = 0; i < 40 && !storage; i++) {
+          await sleep(500);
+          const r = await cdp.send("Runtime.evaluate", { expression, returnByValue: true }, sessionId).catch(() => null);
+          const v = r && r.result && r.result.value;
+          if (v) storage = JSON.parse(v).map(([name, value]) => ({ name, value }));
+        }
+      } catch {}
+      return { cookies, origins: storage ? [{ origin, localStorage: storage }] : [] };
+    } finally {
+      cdp.close();
+    }
+  } finally {
+    try {
+      child.kill();
+    } catch {}
+    for (let i = 0; i < 20 && !gone; i++) await sleep(100);
+  }
+}
+
+/**
+ * 일반 크롬 로그인 창을 연다.
+ *
+ * **로그인하는 동안에는 디버깅 포트를 열지 않는다.** 포트를 연 크롬은 구글이 "안전하지 않은 브라우저" 로 막았다(10/14).
+ * 창이 닫히면 같은 프로필을 화면 없이 다시 켜서 그때 읽는다.
+ * "이어서 열기" 를 켜 둔다 — 끄면 창을 닫을 때 세션 쿠키(만료 없는 로그인 쿠키)가 지워진다
+ *
+ * @param url      처음 보여 줄 주소(사이트 첫 화면)
+ * @param origin   사이트 origin — 이 사이트 쿠키·localStorage 만 저장한다
+ * @param onSave   (storageState) => void — 창이 닫힌 뒤 읽은 것. 못 읽으면 안 부른다
+ * @param onDone   () => void — 다 끝나면(창이 닫히고 읽은 뒤, 또는 시간 초과)
+ * @returns { close, exe } 또는 null(크롬 없음·실행 실패)
+ */
+async function openRealChrome({ url, origin, onSave, onDone, timeoutMs = 10 * 60 * 1000 }) {
+  const exe = findChrome();
+  if (!exe) return null;
+  sweepProfiles();
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), PROFILE_PREFIX));
+  fs.mkdirSync(path.join(dir, "Default"), { recursive: true });
+  fs.writeFileSync(path.join(dir, "Default", "Preferences"), JSON.stringify({ session: { restore_on_startup: 1 } }));
+  const child = spawn(exe, [`--user-data-dir=${dir}`, "--no-first-run", "--no-default-browser-check", "--new-window", url], { stdio: "ignore" });
+  let exited = false;
+  let failed = false;
+  child.on("exit", () => (exited = true));
+  child.on("error", () => ((exited = true), (failed = true)));
+  // 실행 자체가 안 됐으면 Playwright 창으로 돌아가게 null
+  await sleep(1500);
+  if (failed) return null;
+
+  let finished = false;
+  const finish = async () => {
+    if (finished) return;
+    finished = true;
+    clearTimeout(limit);
+    if (!exited) {
+      // 창을 닫듯이 끈다. 강제로 끄면 크롬이 아직 디스크에 안 쓴 쿠키·저장값을 잃는다(10/14 시험에서 비어 나왔다)
+      closeGently(child);
+      for (let i = 0; i < 100 && !exited; i++) await sleep(100);
+      if (!exited) {
+        try {
+          child.kill();
+        } catch {}
+        for (let i = 0; i < 30 && !exited; i++) await sleep(100);
+      }
+    }
+    const state = await readProfile(exe, dir, origin).catch(() => null);
+    if (state) onSave(state);
+    onDone();
+    // 이 프로필에는 사용자가 로그인한 구글 세션 같은 것이 남아 있다. 꼭 지운다 — 크롬이 파일을 몇 초 더 붙잡고 있다(10/14)
+    removeProfile(dir);
+  };
+  const limit = setTimeout(finish, timeoutMs);
+  child.on("exit", finish);
+  // closed: 창이 닫혔나(닫힌 뒤에도 쿠키를 읽고 확인하느라 수십 초 더 걸린다)
+  return { close: finish, exe, closed: () => exited || finished };
+}
+
+module.exports = { findChrome, openRealChrome, readProfile, siteCookie };

package/src/browser/robots.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * 사이트가 "여기는 들어오지 마세요" 라고 적어 둔 것을 읽고 지킨다.
+ *
+ * 가상 사용자는 사람인 척하지 않는다(헤더·UA 로 자기를 밝힌다). 밝히는 쪽을 택한 이상
+ * **robots.txt 도 지켜야 앞뒤가 맞는다.** 고객 사이트라도 마찬가지다 — 고객이 들어가지 말라고 적어 둔 곳이다.
+ *
+ * `Allow` 를 안 읽으면 `Disallow: /` + `Allow: /$` 처럼 예외를 둔 사이트가 통째로 막힌다.
+ * 규칙 고르기는 표준대로 **가장 긴 패턴이 이기고, 길이가 같으면 Allow 가 이긴다.**
+ * `*` 는 아무 글자, `$` 는 경로 끝.
+ *
+ * prototype/explore/driver.js 에 있던 것을 옮겼다(2026-10-07).
+ */
+
+/** 한 줄의 규칙 */
+function toRule(kind, value) {
+  const rx = new RegExp("^" + value.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\$$/, "$").replace(/\*/g, ".*"));
+  return { allow: kind === "allow", path: value, rx, len: value.length };
+}
+
+/** robots.txt 글을 규칙 목록으로. `User-agent: *` 묶음만 본다 */
+function parse(text) {
+  const rules = [];
+  let star = false;
+  for (const raw of String(text || "").split(/\r?\n/)) {
+    const line = raw.replace(/#.*/, "").trim();
+    const m = line.match(/^([A-Za-z-]+)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const k = m[1].toLowerCase();
+    const v = m[2].trim();
+    if (k === "user-agent") star = v === "*";
+    else if (star && (k === "disallow" || k === "allow") && v) rules.push(toRule(k, v));
+  }
+  return rules;
+}
+
+/**
+ * 사이트의 robots.txt 를 한 번 읽는다. 못 읽으면(404·오류) 규칙 없음으로 둔다 —
+ * 없는 것과 못 읽은 것을 구별해 막아버리면 멀쩡한 사이트를 못 돈다.
+ *
+ * **이게 우리가 그 사이트에 보내는 첫 요청이다.** 여기서부터 자기를 밝힌다 —
+ * 브라우저 밖이라 컨텍스트에 붙인 헤더·UA 가 안 따라온다.
+ */
+async function loadRobots(site, { headers = {}, timeoutMs = 10000 } = {}) {
+  const origin = new URL(site).origin;
+  let rules = [];
+  try {
+    const res = await fetch(origin + "/robots.txt", { headers, signal: AbortSignal.timeout(timeoutMs) });
+    if (res.ok) rules = parse(await res.text());
+  } catch (e) {
+    rules = [];
+  }
+  return {
+    origin,
+    rules,
+    /** 이 경로가 막혔나. 막혔으면 그 규칙을 돌려준다 */
+    blocked(pathname) {
+      let best = null;
+      for (const r of rules) {
+        if (!r.rx.test(pathname)) continue;
+        if (!best || r.len > best.len || (r.len === best.len && r.allow)) best = r;
+      }
+      return best && !best.allow ? best.path : null;
+    },
+    describe() {
+      if (!rules.length) return "robots.txt: no rules";
+      const no = rules.filter((r) => !r.allow).length;
+      return `robots.txt: ${rules.length} rules (${no} disallow)`;
+    },
+  };
+}
+
+module.exports = { loadRobots, parse };

package/src/browser/signin.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * 로그인이 됐나 — 세션을 넣은 화면과 안 넣은 화면을 비교한다.
+ *
+ * 세션 파일이 있다고 로그인된 게 아니다. 10/14 bluetags 에서 로그인 전에 창을 닫았는데 쿠키 6개가 저장돼
+ * "Sign-in session found" 로 보였다. 회원 방문자가 비회원 화면을 돌아다니고 그게 회원 기록이 된다.
+ *
+ * 사이트마다 로그인 표시가 다르니 하나로 맞히지 않는다. **안 넣은 화면에 있던 로그인·가입 링크가
+ * 넣은 화면에서 사라졌나**를 본다. 안 넣은 화면에 그런 링크가 처음부터 없으면 알 수 없다고 한다.
+ *
+ * 의존성 없음. Playwright page 를 받는다.
+ */
+
+const SIGNIN_TEXT = /^(sign ?in|log ?in|sign ?up|register|create (an )?account|로그인|회원가입|가입하기)$/i;
+const SIGNIN_HREF = /\/(signin|sign-in|login|log-in|signup|sign-up|register|auth\/signin)(\/|\?|#|$)/i;
+
+/** 화면에 보이는 로그인·가입 링크(최대 5개). 글자가 정확히 그것이거나 주소가 로그인 화면인 것 */
+async function signInMarks(page) {
+  return page
+    .evaluate(
+      ([textSrc, hrefSrc]) => {
+        const text = new RegExp(textSrc, "i");
+        const href = new RegExp(hrefSrc, "i");
+        const out = [];
+        for (const el of document.querySelectorAll('a,button,[role="button"],[role="link"]')) {
+          if (!el.getClientRects().length) continue;
+          const st = getComputedStyle(el);
+          if (st.visibility === "hidden" || st.display === "none" || Number(st.opacity) === 0) continue;
+          const t = (el.innerText || el.getAttribute("aria-label") || "").trim().replace(/\s+/g, " ");
+          const h = el.getAttribute("href") || "";
+          if ((t && t.length <= 30 && text.test(t)) || (h && href.test(h))) out.push(t || h);
+          if (out.length >= 5) break;
+        }
+        return out;
+      },
+      [SIGNIN_TEXT.source, SIGNIN_HREF.source],
+    )
+    .catch(() => []);
+}
+
+/** 한 화면을 열어 자리 잡은 뒤 로그인 링크를 센다 */
+async function marksAt(ctx, url) {
+  const page = await ctx.newPage();
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45000 }).catch(() => {});
+    await page.waitForLoadState("networkidle", { timeout: 6000 }).catch(() => {});
+    // 로그인 상태는 화면이 뜬 뒤 스크립트가 바꾸는 사이트가 많다(next-auth useSession 등)
+    await page.waitForTimeout(1500);
+    return await signInMarks(page);
+  } finally {
+    await page.close().catch(() => {});
+  }
+}
+
+/**
+ * @param anon     세션 없이 연 화면의 로그인 링크
+ * @param signed   세션으로 연 화면의 로그인 링크
+ * @returns { status: "signed_in" | "signed_out" | "unknown", note }
+ */
+function judge(anon, signed) {
+  if (!anon.length) return { status: "unknown", note: "the site shows no sign-in link to compare against" };
+  if (!signed.length) return { status: "signed_in", note: `sign-in links (${anon.slice(0, 2).join(", ")}) are gone when signed in` };
+  return { status: "signed_out", note: `the screen still shows ${signed.slice(0, 2).join(", ")}` };
+}
+
+module.exports = { signInMarks, marksAt, judge };

package/src/persona/people.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * 가상 사용자 만들기 — AI 에 보낼 글과 받을 모양.
+ *
+ * 질문 문구는 주지 않는다. 사람을 질문에 맞춰 만들면 답이 정해진 각본이 된다.
+ * 누구인지·왜 왔는지·그 순간 어떤 상태인지만 정하고, 방문이 어땠는지는 정하지 않는다.
+ *
+ * MCP 로 팔 때 **고객이 사람을 직접 줄 수도 있다.** 그때 들어오는 칸이 아래 PERSON_FIELDS 다.
+ *
+ * 이름은 없다 — 실제 방문자도 이름이 없다. 이름이 있으면 진짜 사람처럼 보여 헷갈리고, AI 가 그 인물을 연기한다.
+ * 사람을 가리킬 때는 우리가 붙이는 번호(id: p1, p2…)를 쓴다.
+ * 의존성 없음. 프롬프트 글은 ../prompts/people.md.
+ */
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const PROMPT_FILE = path.join(__dirname, "..", "prompts", "people.md");
+
+/** 사람 한 명의 칸. 고객이 주는 자리이기도 하다 */
+const PERSON_FIELDS = {
+  type: "object",
+  properties: {
+    device: { type: "string", enum: ["desktop", "mobile"] },
+    background: { type: "string" },
+    goal: { type: "string" },
+    /** 그 방문 순간의 상태. 답할지 말지를 가르는 것은 성격보다 이쪽이다 */
+    moment: { type: "string" },
+    attention: { type: "string", enum: ["skims", "reads", "studies"] },
+    /** 뜬 설문 카드를 평소 어떻게 하는가. 대부분은 무시한다 */
+    surveyHabit: { type: "string", enum: ["ignores", "sometimes", "willing"] },
+    writing: { type: "string", enum: ["careless", "careful"] },
+    /** 이번에 어떻게 들어왔나. 유입이 다르면 떨어지는 자리도 다니는 길도 다르다 */
+    arrival: { type: "string", enum: ["search", "social", "shared", "direct"] },
+    /** 들어오는 화면(경로). 없으면 direct 는 홈, 나머지는 홈에 걸린 상세 하나 */
+    landing: { type: "string" },
+    /** 이 방문이 사이트의 어느 기능에 관한 것인가 — 고르게 퍼뜨리려는 캐스팅용. 방문자에게는 안 보인다 */
+    feature: { type: "string" },
+    /** 어떻게 움직이나(persona.js 규격) */
+    traits: {
+      type: "object",
+      properties: {
+        readCps: { type: "number" },
+        patience: { type: "number" },
+        decisiveness: { type: "number" },
+        distraction: { type: "number" },
+        thoroughness: { type: "number" },
+        mobileEase: { type: "number" },
+      },
+      required: ["readCps", "patience", "decisiveness", "distraction", "thoroughness", "mobileEase"],
+    },
+  },
+  required: ["device", "background", "goal", "moment", "attention", "surveyHabit", "writing", "arrival", "traits"],
+};
+
+const PEOPLE_SCHEMA = {
+  type: "object",
+  properties: { people: { type: "array", items: PERSON_FIELDS } },
+  required: ["people"],
+};
+
+function systemPrompt() {
+  return fs.readFileSync(PROMPT_FILE, "utf8");
+}
+
+/**
+ * @param siteAbout 사이트가 어떤 곳인지 한두 줄
+ * @param path      그 사람들이 이번 방문에서 걸은 길(영어). 자유 탐방이면 "무엇을 하러 왔는지" 만
+ * @param n         몇 명
+ * @param existing  이미 만든 사람들 [{device, goal}] — 겹치지 않게
+ */
+function buildMessage(siteAbout, pathText, n, existing = []) {
+  const lines = ["## Website", siteAbout, "", "## Path every person took", pathText, "", "## How many", `Create ${n} people.`];
+  if (existing.length) {
+    lines.push("", "## Existing people (do not repeat them)");
+    for (const p of existing) lines.push(`- (${p.device}) ${p.goal}`);
+  }
+  return lines.join("\n");
+}
+
+/**
+ * 새로 들어온 사람들에게 번호를 붙인다. 이미 있는 번호 다음부터. 이름이 실려 와도 버린다.
+ * 옛 파일(이름만 있고 번호가 없는 사람)도 여기서 번호를 받는다.
+ */
+function withIds(existing, incoming) {
+  let n = existing.reduce((m, p) => Math.max(m, Number(String(p.id ?? "").replace(/^p/, "")) || 0), 0);
+  const fix = (p) => {
+    const { name: _drop, id, uid, ...rest } = p;
+    return { id: id || `p${++n}`, uid: uid || newUid(), ...rest };
+  };
+  const old = existing.map(fix);
+  return { existing: old, incoming: incoming.map((p) => fix({ ...p, id: null, uid: null })) };
+}
+
+/**
+ * 사람의 고유 값. 번호(p3)는 이 저장소의 people.json 안에서만 겹치지 않는다 —
+ * 파일을 지우거나 팀원이 각자 돌리면 다른 사람이 같은 p1 이 된다. 서버에는 이것도 같이 보낸다
+ */
+const newUid = () => `p_${crypto.randomBytes(6).toString("hex")}`;
+
+/** 움직이는 성향의 씨앗 — 사람마다 다르고, 같은 사람이면 늘 같게 */
+const personKey = (p) => `${p.id ?? ""}|${p.createdAt ?? ""}|${p.goal ?? ""}`;
+
+module.exports = { PERSON_FIELDS, PEOPLE_SCHEMA, PROMPT_FILE, systemPrompt, buildMessage, withIds, personKey };