brand-manager-worker 0.1.0

package/worker/context.js

@@ -0,0 +1,84 @@
+// Preloads everything the drafting agent needs into one string, so the
+// headless call is a single-shot generation instead of ~20 sequential file
+// reads. This is the difference between a draft taking seconds vs minutes.
+// Base files first, then personal (which wins on conflict).
+//
+// Port of brand-manager's src/core/context.ts over the worker's directory
+// layout: base/ is synced from Goose Tools, everything else is the user's own.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { BASE_DIR, DEALS_DIR, PLAYBOOK_DIR, STATS_DIR, VOICE_DIR } from "./paths.js";
+
+const readIf = (p) => {
+  try {
+    return readFileSync(p, "utf8").trim();
+  } catch {
+    return "";
+  }
+};
+
+let cached = null;
+
+export function loadContext() {
+  // Cache for 60s so one burst of jobs doesn't re-read the whole layer.
+  if (cached && Date.now() - cached.at < 60_000) return cached.value;
+
+  const files = [
+    ["RULES: voice-lookup", join(BASE_DIR, "rules/voice-lookup.md")],
+    ["RULES: draft-safety", join(BASE_DIR, "rules/draft-safety.md")],
+    ["MODE: reply", join(BASE_DIR, "modes/reply.md")],
+    ["MODE: negotiate", join(BASE_DIR, "modes/negotiate.md")],
+    ["MODE: contract", join(BASE_DIR, "modes/contract.md")],
+    ["MODE: followup", join(BASE_DIR, "modes/followup.md")],
+    ["VOICE never-words (base)", join(BASE_DIR, "voice/never-words.md")],
+    ["VOICE never-words (personal)", join(VOICE_DIR, "never-words.md")],
+    ["VOICE non-negotiables (base)", join(BASE_DIR, "voice/non-negotiables.md")],
+    ["VOICE non-negotiables (personal)", join(VOICE_DIR, "non-negotiables.md")],
+    ["VOICE (base)", join(BASE_DIR, "voice/voice.md")],
+    ["VOICE (personal — WINS)", join(VOICE_DIR, "voice.md")],
+    ["PLAYBOOK glossary", join(BASE_DIR, "playbook/glossary.md")],
+    ["PLAYBOOK negotiation (base)", join(BASE_DIR, "playbook/negotiation.md")],
+    ["PLAYBOOK negotiation (personal)", join(PLAYBOOK_DIR, "negotiation.md")],
+    ["PLAYBOOK red-flags", join(BASE_DIR, "playbook/red-flags.md")],
+    ["RATE CARD (personal)", join(PLAYBOOK_DIR, "rate-card.md")],
+    ["STATS (current media kit)", join(STATS_DIR, "latest.md")],
+  ];
+
+  const parts = [];
+  for (const [label, p] of files) {
+    const c = readIf(p);
+    if (c) parts.push(`### ${label}\n${c}`);
+  }
+
+  // All deal ledgers (per-brand context + exclusivity-conflict checks). A
+  // mature ledger can run tens of thousands of chars; keep the head (brand,
+  // board block, terms) and the tail (newest updates), dropping the middle.
+  if (existsSync(DEALS_DIR)) {
+    for (const name of readdirSync(DEALS_DIR).filter((n) => n.endsWith(".md")).sort()) {
+      const c = readIf(join(DEALS_DIR, name));
+      if (!c) continue;
+      const body =
+        c.length <= LEDGER_CAP
+          ? c
+          : `${c.slice(0, 2_000)}\n\n[... ledger middle trimmed ...]\n\n${c.slice(-(LEDGER_CAP - 2_000))}`;
+      parts.push(`### DEAL LEDGER: ${name}\n${body}`);
+    }
+  }
+
+  // Backstop only. The old 80k cap silently truncated the rate card, stats
+  // and every ledger once voice.md grew past ~70k — the agent then drafted
+  // without rates and exclusivity checks were no-ops. Found by the parity
+  // harness (2026-08-07); the original repo had the same bug.
+  const value = parts.join("\n\n").slice(0, TOTAL_CAP);
+  cached = { at: Date.now(), value };
+  return value;
+}
+
+const LEDGER_CAP = 8_000;
+const TOTAL_CAP = 350_000;
+
+/** Drop the cache — call after anything edits the personal layer. */
+export function invalidateContext() {
+  cached = null;
+}

package/worker/drafts-log.js

@@ -0,0 +1,38 @@
+// Append-only log of every drafted body, and the lookup that powers
+// learn-from-sent-edits. Port of brand-manager's src/actions/draft-log.ts —
+// same block format, so an imported drafts.md keeps working.
+
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { DRAFTS_LOG } from "./paths.js";
+
+export function appendDraftLog({ account, subject, threadId, draftId, reason, summary, body }) {
+  const block = [
+    `## ${new Date().toISOString()} — [${account}] ${subject}`,
+    `- thread: ${threadId} · draft: ${draftId} · reason: ${reason}`,
+    `- summary: ${summary}`,
+    "",
+    "```text",
+    body,
+    "```",
+    "",
+    "---",
+    "",
+  ].join("\n");
+  appendFileSync(DRAFTS_LOG, block);
+}
+
+/**
+ * The most recent drafted body for a thread — the "before" side of the
+ * learn-from-edit diff. Last match wins (a thread can be drafted repeatedly).
+ */
+export function lastDraftFor(threadId) {
+  if (!existsSync(DRAFTS_LOG)) return null;
+  const blocks = readFileSync(DRAFTS_LOG, "utf8").split("\n## ");
+  let found = null;
+  for (const block of blocks) {
+    if (!block.includes(`thread: ${threadId} `)) continue;
+    const m = block.match(/```text\n([\s\S]*?)\n```/);
+    if (m) found = m[1];
+  }
+  return found;
+}

package/worker/gmail-draft.js

@@ -0,0 +1,211 @@
+// Creating Gmail DRAFTS — the only Gmail write in this package.
+//
+// Two entry points:
+//   createGmailDraft()  — new thread (outreach pitches).
+//   createReplyDraft()  — reply inside an existing thread, with the
+//                         In-Reply-To/References headers and optional file
+//                         attachments, ported from brand-manager's
+//                         src/actions/draft.ts.
+//
+// Both build text+HTML multipart/alternative so Gmail flows paragraphs
+// instead of hard-wrapping long plain-text lines.
+//
+// This file calls drafts.create and NOTHING else. There is no send path in
+// this package — that guarantee lives here in code, not in a prompt.
+
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { getMessageIdHeader } from "./gmail.js";
+
+const GMAIL_DRAFTS = "https://gmail.googleapis.com/gmail/v1/users/me/drafts";
+
+/** Email bodies must use CRLF line endings (RFC 5322). */
+const toCRLF = (s) => s.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n");
+
+const escapeHtml = (s) =>
+  s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+/**
+ * Plain text → simple clean HTML: blank lines separate paragraphs, "- " lines
+ * become bullets, "1. " lines become a numbered list, in-block breaks -> <br>.
+ */
+function bodyToHtml(text) {
+  const lines = toCRLF(text).split("\r\n");
+  const out = [];
+  let para = [];
+  let list = [];
+  let listType = null;
+
+  const flushPara = () => {
+    if (para.length) out.push(`<p>${para.join("<br>")}</p>`);
+    para = [];
+  };
+  const flushList = () => {
+    if (list.length && listType)
+      out.push(`<${listType}>${list.map((li) => `<li>${li}</li>`).join("")}</${listType}>`);
+    list = [];
+    listType = null;
+  };
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (line === "") {
+      flushPara();
+      flushList();
+      continue;
+    }
+    const bullet = /^-\s+(.*)$/.exec(line);
+    const numbered = /^\d+\.\s+(.*)$/.exec(line);
+    if (bullet) {
+      flushPara();
+      if (listType && listType !== "ul") flushList();
+      listType = "ul";
+      list.push(escapeHtml(bullet[1]));
+    } else if (numbered) {
+      flushPara();
+      if (listType && listType !== "ol") flushList();
+      listType = "ol";
+      list.push(escapeHtml(numbered[1]));
+    } else {
+      flushList();
+      para.push(escapeHtml(line));
+    }
+  }
+  flushPara();
+  flushList();
+  return `<div style="font-family:Arial,Helvetica,sans-serif;font-size:14px;line-height:1.5;color:#1a1a1a;">${out.join("")}</div>`;
+}
+
+function buildMime({ to, subject, bodyText }) {
+  const alt = `alt_${Math.random().toString(36).slice(2)}`;
+  return [
+    `To: ${to}`,
+    `Subject: ${subject}`,
+    "MIME-Version: 1.0",
+    `Content-Type: multipart/alternative; boundary="${alt}"`,
+    "",
+    `--${alt}`,
+    'Content-Type: text/plain; charset="UTF-8"',
+    "",
+    toCRLF(bodyText),
+    `--${alt}`,
+    'Content-Type: text/html; charset="UTF-8"',
+    "",
+    toCRLF(bodyToHtml(bodyText)),
+    `--${alt}--`,
+  ].join("\r\n");
+}
+
+async function postDraft(accessToken, message) {
+  const res = await fetch(GMAIL_DRAFTS, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ message }),
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    if (res.status === 401)
+      throw new Error("Gmail access expired — reconnect Gmail on goosetools.com");
+    throw new Error(`Gmail draft failed (${res.status}): ${body.slice(0, 300)}`);
+  }
+  const json = await res.json();
+  return json.id ?? null;
+}
+
+/**
+ * Create a draft on a NEW thread. Returns the Gmail draft id. Throws with a
+ * readable message on failure (expired grant → the site shows "reconnect").
+ */
+export async function createGmailDraft(accessToken, { to, subject, bodyText }) {
+  const raw = Buffer.from(buildMime({ to, subject, bodyText })).toString("base64url");
+  return postDraft(accessToken, { raw });
+}
+
+const ATTACH_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".pdf": "application/pdf",
+  ".gif": "image/gif",
+};
+const mimeType = (file) => ATTACH_MIME[extname(file).toLowerCase()] ?? "application/octet-stream";
+
+/**
+ * Full reply MIME: threading headers + text/HTML alternative, wrapped in
+ * multipart/mixed when there are file attachments. Exported for tests.
+ */
+export function buildReplyMime({ to, subject, bodyText, messageIdHeader = "", attachments = [] }) {
+  const headers = [
+    `To: ${to}`,
+    `Subject: ${subject}`,
+    messageIdHeader ? `In-Reply-To: ${messageIdHeader}` : "",
+    messageIdHeader ? `References: ${messageIdHeader}` : "",
+    "MIME-Version: 1.0",
+  ].filter(Boolean);
+
+  const alt = `alt_${Math.random().toString(36).slice(2)}`;
+  const alternative = [
+    `--${alt}`,
+    'Content-Type: text/plain; charset="UTF-8"',
+    "",
+    toCRLF(bodyText),
+    `--${alt}`,
+    'Content-Type: text/html; charset="UTF-8"',
+    "",
+    toCRLF(bodyToHtml(bodyText)),
+    `--${alt}--`,
+  ];
+
+  if (attachments.length === 0) {
+    return [
+      ...headers,
+      `Content-Type: multipart/alternative; boundary="${alt}"`,
+      "",
+      ...alternative,
+    ].join("\r\n");
+  }
+
+  const mixed = `mixed_${Math.random().toString(36).slice(2)}`;
+  const parts = [
+    ...headers,
+    `Content-Type: multipart/mixed; boundary="${mixed}"`,
+    "",
+    `--${mixed}`,
+    `Content-Type: multipart/alternative; boundary="${alt}"`,
+    "",
+    ...alternative,
+  ];
+  for (const file of attachments) {
+    parts.push(
+      `--${mixed}`,
+      `Content-Type: ${mimeType(file)}; name="${basename(file)}"`,
+      "Content-Transfer-Encoding: base64",
+      `Content-Disposition: attachment; filename="${basename(file)}"`,
+      "",
+      readFileSync(file).toString("base64"),
+    );
+  }
+  parts.push(`--${mixed}--`);
+  return parts.join("\r\n");
+}
+
+/**
+ * Create a REPLY draft inside an existing thread. Fetches the Message-ID of
+ * the message being replied to so Gmail threads it correctly (best-effort —
+ * a missing header degrades threading, never blocks the draft).
+ */
+export async function createReplyDraft(
+  accessToken,
+  { threadId, inReplyToMessageId, to, subject, bodyText, attachments = [] },
+) {
+  const messageIdHeader = inReplyToMessageId
+    ? await getMessageIdHeader(accessToken, inReplyToMessageId)
+    : "";
+  const raw = Buffer.from(
+    buildReplyMime({ to, subject, bodyText, messageIdHeader, attachments }),
+  ).toString("base64url");
+  return postDraft(accessToken, threadId ? { threadId, raw } : { raw });
+}

package/worker/gmail.js

@@ -0,0 +1,187 @@
+// Reading Gmail with the short-lived access token handed down in each claim.
+//
+// Ported from brand-manager's src/sources/gmail.ts, swapped from googleapis to
+// plain REST (matches gmail-draft.js — fewer deps, same API). Everything here
+// is read-only: threads.list, threads.get, messages.get, attachments.get.
+// Draft creation lives in gmail-draft.js; there is no send path in this
+// package.
+
+const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+
+const LOOKBACK = "newer_than:14d";
+
+/** Keywords that mark a thread as brand/collab outreach (for a personal inbox). */
+const BRAND_TERMS = [
+  "collab", "collaboration", "partnership", "sponsor", "sponsorship", "brand",
+  '"paid partnership"', "whitelisting", '"rate card"', "UGC", "gifting", "deliverables",
+];
+
+/** Gmail search query. Brand inbox = broad; personal inbox = brand-terms only. */
+export function queryFor(brandOnly) {
+  // in:spam is opt-in for Gmail search — without it, misfiled brand outreach is
+  // invisible and never gets a draft (real misses found 2026-07-30).
+  if (brandOnly)
+    return `${LOOKBACK} (${BRAND_TERMS.join(" OR ")}) (in:anywhere OR in:spam) -in:chats -in:trash`;
+  return `${LOOKBACK} (in:inbox OR category:promotions OR in:spam) -in:chats`;
+}
+
+async function gmailGet(accessToken, path, params = {}) {
+  const url = new URL(`${API}/${path}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (Array.isArray(v)) for (const item of v) url.searchParams.append(k, item);
+    else if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
+  }
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${accessToken}` } });
+  if (res.status === 401)
+    throw new Error("Gmail access expired — reconnect Gmail on goosetools.com");
+  if (!res.ok)
+    throw new Error(`Gmail ${path} failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
+  return res.json();
+}
+
+const header = (headers, name) =>
+  headers?.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? "";
+
+function collectAttachments(part, out) {
+  if (!part) return;
+  if (part.body?.attachmentId && part.filename) {
+    out.push({
+      id: part.body.attachmentId,
+      filename: part.filename,
+      mimeType: part.mimeType ?? "application/octet-stream",
+    });
+  }
+  for (const child of part.parts ?? []) collectAttachments(child, out);
+}
+
+/** Full plain-text body with quoted reply-history stripped. Exported for tests. */
+export function plainBody(payload) {
+  const parts = [];
+  const walk = (p) => {
+    if (!p) return;
+    if (p.mimeType === "text/plain" && p.body?.data)
+      parts.push(Buffer.from(p.body.data, "base64url").toString("utf8"));
+    for (const c of p.parts ?? []) walk(c);
+  };
+  walk(payload);
+  let text = parts.join("\n");
+  // Cut quoted history (replies/forwards) so only this message's own content remains.
+  text = text.split(/\n>+ ?/)[0];
+  text = text.split(/\nOn .{0,80}wrote:/)[0];
+  text = text.split(/\n-{3,} ?Original Message|\n-{3,} ?Forwarded message/)[0];
+  return text.trim();
+}
+
+const cleanSnippet = (s) =>
+  (s ?? "").replace(/'/g, "'").replace(/&/g, "&").replace(/"/g, '"');
+
+function toMessage(raw) {
+  const headers = raw.payload?.headers;
+  const attachments = [];
+  collectAttachments(raw.payload, attachments);
+  const labelIds = raw.labelIds ?? [];
+  const toRaw = header(headers, "To");
+  return {
+    id: raw.id,
+    from: header(headers, "From"),
+    to: toRaw ? toRaw.split(",").map((s) => s.trim()) : [],
+    subject: header(headers, "Subject"),
+    date: raw.internalDate
+      ? new Date(Number(raw.internalDate)).toISOString()
+      : new Date().toISOString(),
+    snippet: cleanSnippet(raw.snippet),
+    body: plainBody(raw.payload),
+    fromMe: labelIds.includes("SENT"),
+    attachments,
+  };
+}
+
+/**
+ * One thread, mapped. Drafts in the thread are our own unsent replies — they
+ * must NOT count as the latest message (otherwise the loop tries to "reply"
+ * to its own draft). Returns null for a drafts-only thread.
+ */
+export async function getThread(accessToken, accountEmail, threadId) {
+  const data = await gmailGet(accessToken, `threads/${threadId}`, { format: "full" });
+  const all = data.messages ?? [];
+  const hasUnsentDraft = all.some((m) => (m.labelIds ?? []).includes("DRAFT"));
+  const messages = all
+    .filter((m) => !(m.labelIds ?? []).includes("DRAFT"))
+    .map(toMessage)
+    .sort((a, b) => Date.parse(a.date) - Date.parse(b.date));
+  if (messages.length === 0) return null;
+  return {
+    id: threadId,
+    account: accountEmail,
+    subject: messages[0]?.subject ?? "",
+    messages,
+    last: messages[messages.length - 1],
+    hasUnsentDraft,
+  };
+}
+
+/** Candidate brand threads (mapped, newest message last per thread). */
+export async function fetchThreads(accessToken, accountEmail, { brandOnly = false } = {}) {
+  const data = await gmailGet(accessToken, "threads", {
+    q: queryFor(brandOnly),
+    maxResults: 40,
+  });
+  const threads = [];
+  for (const t of data.threads ?? []) {
+    if (!t.id) continue;
+    const thread = await getThread(accessToken, accountEmail, t.id);
+    if (thread) threads.push(thread);
+  }
+  return threads;
+}
+
+/**
+ * Raw Gmail search, query passed through as written (no lookback, no brand
+ * filter). Metadata only — this is the conversational "look anything up" path.
+ */
+export async function searchThreads(accessToken, accountEmail, query, { limit = 15 } = {}) {
+  const data = await gmailGet(accessToken, "threads", { q: query, maxResults: limit });
+  const hits = [];
+  for (const t of data.threads ?? []) {
+    if (!t.id) continue;
+    const full = await gmailGet(accessToken, `threads/${t.id}`, {
+      format: "metadata",
+      metadataHeaders: ["Subject", "From", "Date"],
+    });
+    const msgs = (full.messages ?? []).filter((m) => !(m.labelIds ?? []).includes("DRAFT"));
+    const last = msgs[msgs.length - 1];
+    if (!last) continue;
+    hits.push({
+      account: accountEmail,
+      id: t.id,
+      subject: header(msgs[0]?.payload?.headers, "Subject"),
+      from: header(last.payload?.headers, "From"),
+      date: last.internalDate ? new Date(Number(last.internalDate)).toISOString() : "",
+      snippet: cleanSnippet(last.snippet),
+      messageCount: msgs.length,
+    });
+  }
+  return hits.sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
+}
+
+/** Raw bytes of one attachment. */
+export async function getAttachment(accessToken, messageId, attachmentId) {
+  const data = await gmailGet(
+    accessToken,
+    `messages/${messageId}/attachments/${attachmentId}`,
+  );
+  return Buffer.from(data.data ?? "", "base64url");
+}
+
+/** RFC822 Message-ID header of a message (for reply threading). Best-effort. */
+export async function getMessageIdHeader(accessToken, messageId) {
+  try {
+    const data = await gmailGet(accessToken, `messages/${messageId}`, {
+      format: "metadata",
+      metadataHeaders: ["Message-ID"],
+    });
+    return header(data.payload?.headers, "Message-ID");
+  } catch {
+    return "";
+  }
+}