brand-manager-worker 0.1.0

package/worker/handlers.js

@@ -0,0 +1,412 @@
+// Inbound job handlers: everything Brand Manager does with a claimed job.
+// (Outreach handlers live in outreach.js.)
+//
+// Every handler returns the complete() payload shape:
+//   { ok, summary?, resultBody?, flags?, sessionId?, error?, mirror? }
+//
+// The never-send guarantee: handlers call createReplyDraft/createGmailDraft
+// and nothing else touches Gmail writes. Nothing in this package references
+// Gmail's send endpoint — test/no-send.test.js enforces that by pattern.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { classify, decide, learnFromEdit } from "./agent.js";
+import { extractContracts } from "./attachments.js";
+import { session } from "./claude.js";
+import { invalidateContext } from "./context.js";
+import { appendDraftLog, lastDraftFor } from "./drafts-log.js";
+import { createReplyDraft } from "./gmail-draft.js";
+import { fetchThreads, getThread } from "./gmail.js";
+import { buildMirror } from "./mirror.js";
+import {
+  BRAND_DIR,
+  DEALS_DIR,
+  PLAYBOOK_DIR,
+  SCREENSHOTS_DIR,
+  STATS_DIR,
+  VOICE_DIR,
+} from "./paths.js";
+import * as state from "./state.js";
+
+const FOLLOWUP_DAYS = 3;
+
+const noGmail = () => ({
+  ok: false,
+  error: "Gmail isn't connected — connect your email on goosetools.com/dashboard/brand-manager",
+});
+
+/** Thread metadata rows for the mirror, from fetched threads. */
+const threadMeta = (threads) =>
+  threads.map((t) => ({
+    threadId: t.id,
+    accountEmail: t.account,
+    fromName: t.last.from.replace(/\s*<[^>]*>\s*/, "").trim() || null,
+    fromEmail: (t.last.from.match(/<([^>]+)>/)?.[1] ?? t.last.from).trim() || null,
+    subject: t.subject,
+    lastMessageAt: t.last.date,
+    hasUnsentDraft: t.hasUnsentDraft,
+  }));
+
+/** Resolve decision attachment paths ("stats/screenshots/x.png") under BRAND_DIR. */
+const resolveAttachments = (paths = []) =>
+  paths.map((p) => (p.startsWith("/") ? p : join(BRAND_DIR, p))).filter((p) => existsSync(p));
+
+/**
+ * Draft a reply on one thread (the on-demand path, and the per-thread step of
+ * a scan). `instruction` steers this draft only.
+ */
+async function draftForThread(job, thread) {
+  const contracts = await extractContracts(
+    job.gmailAccessToken,
+    thread.last.id,
+    thread.last.attachments,
+  );
+  const reason = job.kind === "followup" ? "followup-due" : "new-or-reply";
+  const decision = await decide({ thread, reason, instruction: job.instruction, contracts });
+  if (!decision) {
+    // Parse/agent failure: retryable. Do NOT mark handled.
+    return { ok: false, error: "Agent returned no parseable decision (will retry)" };
+  }
+
+  if (decision.action === "skip") {
+    if (reason === "new-or-reply") state.markHandled(thread.id, thread.last.id);
+    return {
+      ok: true,
+      summary: `skip — ${decision.summary}`,
+      mirror: buildMirror({ threads: threadMeta([thread]) }),
+    };
+  }
+
+  const draftId = await createReplyDraft(job.gmailAccessToken, {
+    threadId: thread.id,
+    inReplyToMessageId: thread.last.id,
+    to: decision.to ?? thread.last.from,
+    subject: decision.subject ?? `Re: ${thread.subject}`,
+    bodyText: decision.body ?? "",
+    attachments: resolveAttachments(decision.attachments),
+  });
+
+  // Record the drafted body so a later Gmail edit can be diffed and learned from.
+  appendDraftLog({
+    account: thread.account,
+    subject: thread.subject,
+    threadId: thread.id,
+    draftId,
+    reason,
+    summary: decision.summary,
+    body: decision.body ?? "",
+  });
+
+  if (reason === "followup-due") state.markFollowup(thread.id, thread.last.id);
+  else state.markHandled(thread.id, thread.last.id);
+
+  return {
+    ok: true,
+    summary: decision.summary,
+    resultBody: decision.body ?? "",
+    flags: decision.flags ?? [],
+    mirror: buildMirror({ threads: threadMeta([thread]) }),
+  };
+}
+
+/** kind: draft | followup — one thread, threadId pinned by the job. */
+export async function runDraft(job) {
+  if (!job.gmailAccessToken) return noGmail();
+  if (!job.threadId) return { ok: false, error: "draft job has no threadId" };
+  const thread = await getThread(job.gmailAccessToken, job.accountEmail, job.threadId);
+  if (!thread) return { ok: false, error: `Thread ${job.threadId} not found or drafts-only` };
+  return draftForThread(job, thread);
+}
+
+/**
+ * kind: scan — the background poll, ported from pipeline.runOnce(). Fetches
+ * brand threads, learns from sent edits, classifies, drafts what needs
+ * drafting. The server cron enqueues one of these per connected user on the
+ * old 15-minute cadence.
+ */
+export async function runScan(job) {
+  if (!job.gmailAccessToken) return noGmail();
+  const threads = await fetchThreads(job.gmailAccessToken, job.accountEmail, {
+    brandOnly: Boolean(job.payload?.brandOnly),
+  });
+
+  const lines = [];
+  const flags = [];
+  for (const thread of threads) {
+    // Learn from the creator's edits to a sent reply (independent of drafting).
+    try {
+      const last = thread.last;
+      if (last.fromMe && !state.isLearned(thread.id, last.id)) {
+        const original = lastDraftFor(thread.id);
+        state.markLearned(thread.id, last.id);
+        if (original) {
+          const learned = await learnFromEdit({
+            subject: thread.subject,
+            brandContact: last.to.join(", ") || last.from,
+            original,
+            sent: last.body,
+          });
+          if (learned && !/no durable lesson/i.test(learned)) lines.push(`voice learned — ${learned}`);
+        }
+      }
+    } catch {
+      // Learning must never block drafting.
+    }
+
+    const reason = classify(thread, {
+      followupDays: FOLLOWUP_DAYS,
+      isHandled: state.isHandled,
+      lastFollowupAt: state.lastFollowupAt,
+    });
+    if (!reason) continue;
+
+    try {
+      const result = await draftForThread(
+        { ...job, kind: reason === "followup-due" ? "followup" : "draft", instruction: null },
+        thread,
+      );
+      if (result.ok) lines.push(`${thread.subject}: ${result.summary}`);
+      else lines.push(`${thread.subject}: ${result.error}`);
+      for (const f of result.flags ?? []) flags.push(`${thread.subject}: ${f}`);
+    } catch (err) {
+      lines.push(`${thread.subject}: ${err.message}`);
+    }
+  }
+
+  return {
+    ok: true,
+    summary: lines.length ? lines.join(" · ").slice(0, 1900) : "No new brand mail needing a draft.",
+    flags,
+    mirror: buildMirror({ threads: threadMeta(threads) }),
+  };
+}
+
+/**
+ * kind: chat — a real, resumable Claude session scoped to the brand
+ * directory. This is the "talk to it like in Claude Code" surface: it can
+ * read ledgers, edit the rate card, and remember the previous turn.
+ */
+export async function runChat(job) {
+  // If the chat is about a specific thread, inline it — the session has no
+  // Gmail tools yet, so the worker does the fetch.
+  let threadBlock = "";
+  if (job.threadId && job.gmailAccessToken) {
+    const thread = await getThread(job.gmailAccessToken, job.accountEmail, job.threadId);
+    if (thread) {
+      threadBlock = [
+        ``,
+        `The creator is asking about this Gmail thread (oldest first):`,
+        ...thread.messages.map(
+          (m) => `--- ${m.fromMe ? "CREATOR" : "BRAND"} | ${m.from} | ${m.date}\n${(m.body || m.snippet).slice(0, 4000)}`,
+        ),
+      ].join("\n");
+    }
+  }
+
+  const history = (job.history ?? [])
+    .map((h) => `USER: ${h.instruction ?? ""}\nYOU: ${h.body ?? ""}`)
+    .join("\n\n");
+
+  const prompt = [
+    `You are brand-manager, the creator's brand-deal agent, chatting with them on Goose Tools.`,
+    `Your working directory is their brand-manager folder: base/ holds modes and rules (read`,
+    `base/rules/feedback-loop.md before saving any preference), voice/ playbook/ deals/ stats/ are`,
+    `their personal layer — read what you need, and APPEND edits per the feedback loop.`,
+    `You cannot send email, and you cannot access Gmail from this session.`,
+    job.sessionId ? "" : history ? `\nConversation so far:\n${history}` : "",
+    threadBlock,
+    ``,
+    `The creator says:`,
+    job.instruction ?? "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  const { text, sessionId } = await session(prompt, {
+    cwd: BRAND_DIR,
+    sessionId: job.sessionId ?? null,
+  });
+  invalidateContext();
+  return {
+    ok: true,
+    summary: "chat turn",
+    resultBody: text,
+    sessionId,
+    mirror: buildMirror({ threads: [] }),
+  };
+}
+
+/**
+ * kind: voice-audit — read the creator's SENT brand threads and write their
+ * negotiation voice guide. The onboarding moment; port of modes/voice-audit.md
+ * from interactive-only to a job.
+ */
+export async function runVoiceAudit(job) {
+  if (!job.gmailAccessToken) return noGmail();
+
+  // Their own sent brand mail, rendered to a scratch file the session reads.
+  const threads = await fetchThreads(job.gmailAccessToken, job.accountEmail, { brandOnly: true });
+  const sentHeavy = threads
+    .filter((t) => t.messages.some((m) => m.fromMe))
+    .slice(0, 20);
+  if (sentHeavy.length === 0) {
+    return {
+      ok: false,
+      error:
+        "No sent brand threads found to learn from — describe your voice or paste examples instead.",
+    };
+  }
+
+  const tmpDir = join(BRAND_DIR, "tmp");
+  mkdirSync(tmpDir, { recursive: true });
+  const corpus = sentHeavy
+    .map((t) =>
+      [
+        `## Thread: ${t.subject}`,
+        ...t.messages
+          .filter((m) => m.fromMe)
+          .map((m) => `### Sent ${m.date}\n${m.body.slice(0, 3000)}`),
+      ].join("\n\n"),
+    )
+    .join("\n\n---\n\n");
+  const corpusPath = join(tmpDir, "sent-brand-threads.md");
+  writeFileSync(corpusPath, corpus);
+
+  const prompt = [
+    `You are brand-manager. Follow base/modes/voice-audit.md.`,
+    `The creator's sent brand emails are in tmp/sent-brand-threads.md — read that file, mine how they`,
+    `actually write to brands (openers, how they quote rates, how they push back, sign-off), and write:`,
+    `- voice/voice.md (their brand-negotiation voice)`,
+    `- playbook/rate-card.md and playbook/negotiation.md IF real rates/moves appear in the emails —`,
+    `  never invent a number that isn't in their own sent mail.`,
+    `This is a brand-negotiation voice, distinct from any social-post voice.`,
+    `Finally output a short summary of what you learned, written to the creator.`,
+  ].join("\n");
+
+  const { text, sessionId } = await session(prompt, {
+    cwd: BRAND_DIR,
+    sessionId: job.sessionId ?? null,
+  });
+  invalidateContext();
+  return {
+    ok: true,
+    summary: "voice audit complete",
+    resultBody: text,
+    sessionId,
+    mirror: buildMirror({ threads: [] }),
+  };
+}
+
+/**
+ * kind: learn — fold a correction back into the personal layer. Primary
+ * path diffs the sent Gmail message against the logged draft; fallback uses
+ * the chat-turn history the server sends (caption-maker style).
+ */
+export async function runLearn(job) {
+  if (job.threadId && job.gmailAccessToken) {
+    const thread = await getThread(job.gmailAccessToken, job.accountEmail, job.threadId);
+    const last = thread?.last;
+    if (thread && last?.fromMe && !state.isLearned(thread.id, last.id)) {
+      const original = lastDraftFor(thread.id);
+      state.markLearned(thread.id, last.id);
+      if (original) {
+        const summary = await learnFromEdit({
+          subject: thread.subject,
+          brandContact: last.to.join(", ") || last.from,
+          original,
+          sent: last.body,
+        });
+        return {
+          ok: true,
+          summary: summary || "no durable lesson",
+          mirror: buildMirror({ threads: [] }),
+        };
+      }
+    }
+    return { ok: true, summary: "nothing to learn from yet" };
+  }
+
+  // Fallback: learn from a chat correction (history carries the turns).
+  const turns = job.history ?? [];
+  const before = turns.length >= 2 ? turns[turns.length - 2]?.body : null;
+  const after = turns[turns.length - 1]?.body;
+  const correction = turns[turns.length - 1]?.instruction;
+  if (!after || !correction) return { ok: true, summary: "nothing to learn from" };
+  const summary = await learnFromEdit({
+    subject: "(chat refinement)",
+    brandContact: "(n/a)",
+    original: before ?? "",
+    sent: after,
+  });
+  return { ok: true, summary: summary || "no durable lesson", mirror: buildMirror({ threads: [] }) };
+}
+
+/**
+ * kind: stats — read uploaded stat screenshots and rewrite stats/latest.md.
+ * payload.photoUrls are public blob URLs; download locally, then a
+ * tool-enabled session reads the images (the carousel worker's trick).
+ */
+export async function runStats(job) {
+  const urls = job.payload?.photoUrls ?? [];
+  if (urls.length === 0) return { ok: false, error: "stats job has no photoUrls" };
+
+  mkdirSync(SCREENSHOTS_DIR, { recursive: true });
+  const stamp = new Date().toISOString().slice(0, 10);
+  const saved = [];
+  for (let i = 0; i < urls.length; i++) {
+    const res = await fetch(urls[i]);
+    if (!res.ok) continue;
+    const ext = (new URL(urls[i]).pathname.match(/\.(png|jpe?g|webp)$/i)?.[0] ?? ".png").toLowerCase();
+    const dest = join(SCREENSHOTS_DIR, `${stamp}-${i}${ext}`);
+    writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+    saved.push(dest);
+  }
+  if (saved.length === 0) return { ok: false, error: "could not download any screenshots" };
+
+  const prompt = [
+    `You are brand-manager. Follow base/modes/stats-intake.md.`,
+    `Read these stat screenshots and update stats/latest.md with the current numbers (followers, reel`,
+    `views, reach, engagement, audience demographics). Keep the screenshots referenced for attaching`,
+    `to brand replies. Screenshots:\n${saved.join("\n")}`,
+    `Report one line summarizing what changed.`,
+  ].join("\n");
+
+  const { text } = await session(prompt, { cwd: BRAND_DIR, timeoutMs: 5 * 60 * 1000 });
+  invalidateContext();
+  const latest = join(STATS_DIR, "latest.md");
+  return {
+    ok: true,
+    summary: text.trim().split("\n").filter(Boolean).pop() ?? "stats updated",
+    // The rewritten media kit rides back for the platform stats row (Phase 3).
+    resultBody: existsSync(latest) ? readFileSync(latest, "utf8") : "",
+    mirror: buildMirror({ threads: [] }),
+  };
+}
+
+/** kind: edit — apply a website edit to the local file. Deterministic, no Claude. */
+export async function runEdit(job) {
+  const { target, body } = job.payload ?? {};
+  const files = {
+    voice: join(VOICE_DIR, "voice.md"),
+    "never-words": join(VOICE_DIR, "never-words.md"),
+    "non-negotiables": join(VOICE_DIR, "non-negotiables.md"),
+    "rate-card": join(PLAYBOOK_DIR, "rate-card.md"),
+    negotiation: join(PLAYBOOK_DIR, "negotiation.md"),
+  };
+  let dest = files[target];
+  // deals/<slug> targets a ledger; the slug is validated to a bare filename.
+  if (!dest && typeof target === "string" && target.startsWith("deals/")) {
+    const slug = target.slice(6);
+    if (/^[a-z0-9-]+$/.test(slug)) dest = join(DEALS_DIR, `${slug}.md`);
+  }
+  if (!dest || typeof body !== "string") {
+    return { ok: false, error: `edit job has an unknown target '${target}'` };
+  }
+  writeFileSync(dest, body);
+  invalidateContext();
+  return {
+    ok: true,
+    summary: `updated ${target}`,
+    mirror: buildMirror({ threads: [] }),
+  };
+}

package/worker/index.js

@@ -0,0 +1,120 @@
+// The Goose Tools brand worker loop.
+//
+// Claims a job every 30s, does it here on this machine, reports back. The
+// user's voice, rates, ledgers and drafts are files in ~/.goosetools/brand-manager
+// — this machine owns them; the website shows a copy.
+//
+// It never sends email. Every reply is created as a Gmail DRAFT, the Gmail
+// scopes granted don't include sending, and nothing in this package touches
+// Gmail's send endpoint (test/no-send.test.js enforces this by pattern).
+// That guarantee lives in code, not in a prompt.
+
+import { api, syncAssets, BASE_URL, POLL_MS, TOKEN } from "./api.js";
+import { BRAND_DIR, ensureDirs } from "./paths.js";
+import { buildMirror } from "./mirror.js";
+import { runOutreachChat, runOutreachDraft } from "./outreach.js";
+import {
+  runChat,
+  runDraft,
+  runEdit,
+  runLearn,
+  runScan,
+  runStats,
+  runVoiceAudit,
+} from "./handlers.js";
+
+if (!TOKEN) {
+  console.error(
+    "\nThis computer isn't connected yet.\n" +
+      "Get your command from https://goosetools.com/dashboard/brand-manager\n" +
+      "  npx --yes brand-manager-worker install --token gt_…\n",
+  );
+  process.exit(1);
+}
+
+ensureDirs();
+console.log(`brand worker → ${BASE_URL}`);
+console.log(`files        → ${BRAND_DIR}`);
+
+async function handle(job) {
+  switch (job.kind) {
+    case "index": {
+      // Pure local read — no Gmail needed, so this works with nothing else
+      // configured and is what rebuild-mirror.ts exercises.
+      return {
+        ok: true,
+        summary: "Indexed local files",
+        mirror: buildMirror({ threads: [] }),
+      };
+    }
+    // Inbound Brand Manager (handlers.js).
+    case "draft":
+    case "followup":
+      return runDraft(job);
+    case "scan":
+      return runScan(job);
+    case "chat":
+      return runChat(job);
+    case "voice-audit":
+      return runVoiceAudit(job);
+    case "learn":
+      return runLearn(job);
+    case "stats":
+      return runStats(job);
+    case "edit":
+      return runEdit(job);
+    // Brand Outreach (its own tool on the site; same worker, same token).
+    case "outreach-chat":
+      return runOutreachChat(job);
+    case "outreach-draft":
+      return runOutreachDraft(job);
+    default:
+      return { ok: false, error: `Unknown job kind '${job.kind}'` };
+  }
+}
+
+let lastAssetsVersion = null;
+
+async function tick() {
+  const job = await api("claim");
+  if (!job) return false;
+
+  console.log(`· claimed ${job.kind} (${job.id})`);
+
+  // Keep the base prompt layer current. Cheap: the claim tells us the server's
+  // version, so this only does work when prompts actually changed.
+  if (job.assetsVersion && job.assetsVersion !== lastAssetsVersion) {
+    try {
+      const synced = await syncAssets(job.assetsVersion);
+      if (synced) console.log(`· synced base prompts → ${synced}`);
+      lastAssetsVersion = job.assetsVersion;
+    } catch (err) {
+      // A failed sync shouldn't drop the job — the previous base layer is
+      // still on disk and still valid.
+      console.error(`· asset sync failed (continuing): ${err.message}`);
+    }
+  }
+
+  let result;
+  try {
+    result = await handle(job);
+  } catch (err) {
+    result = { ok: false, error: err?.message ?? String(err) };
+  }
+
+  await api("complete", { jobId: job.id, ...result });
+  console.log(result.ok ? `· done ${job.id}` : `· failed ${job.id}: ${result.error}`);
+  return true;
+}
+
+while (true) {
+  try {
+    // Keep draining while there's work; only sleep once the queue is empty, so
+    // a burst of jobs doesn't take 30s each.
+    const did = await tick();
+    if (did) continue;
+  } catch (err) {
+    console.error(`· ${err?.message ?? err}`);
+  }
+  await new Promise((r) => setTimeout(r, POLL_MS));
+}

package/worker/mirror.js

@@ -0,0 +1,95 @@
+// Building the projection we push to Goose Tools.
+//
+// The website renders from this. It is deliberately a one-way overwrite: the
+// files on this machine are the truth, and anything the server has is a stale
+// copy that the next push corrects. Nothing here merges.
+//
+// What goes up: deal ledgers, the knowledge files, and thread metadata.
+// What never goes up: incoming message bodies, quoted history, attachment or
+// contract text. brand-manager doesn't persist those either — a contract is
+// extracted at draft time and discarded, and the durable record is the ledger
+// the agent writes after reading it.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { DEALS_DIR, PLAYBOOK_DIR, VOICE_DIR } from "./paths.js";
+
+// Same block the ledgers already carry, parsed the same way brand-manager's
+// board export does (src/board/export.ts).
+const BOARD_RE = /<!--\s*board\s*([\s\S]*?)-->/;
+
+function readIfExists(file) {
+  return existsSync(file) ? readFileSync(file, "utf8") : null;
+}
+
+/** Every deals/<slug>.md, with stage lifted out of its board block. */
+export function collectDeals() {
+  if (!existsSync(DEALS_DIR)) return [];
+  const out = [];
+  for (const name of readdirSync(DEALS_DIR).sort()) {
+    if (!name.endsWith(".md")) continue;
+    const slug = basename(name, ".md");
+    const ledgerMd = readFileSync(join(DEALS_DIR, name), "utf8");
+
+    // A malformed block is reported, never guessed at — same rule as the
+    // original exporter. We still push the ledger text so the deal doesn't
+    // vanish from the UI just because its JSON is temporarily broken.
+    let brand = slug;
+    let stage = null;
+    const match = ledgerMd.match(BOARD_RE);
+    if (match) {
+      try {
+        const block = JSON.parse(match[1]);
+        if (typeof block.brand === "string" && block.brand.trim()) brand = block.brand;
+        if (typeof block.stage === "string") stage = block.stage;
+      } catch {
+        // leave brand/stage as the fallbacks
+      }
+    }
+    out.push({ slug, brand, stage, ledgerMd });
+  }
+  return out;
+}
+
+/** The personal knowledge files, as the site's editable documents. */
+export function collectKnowledge() {
+  const files = [
+    ["voice", join(VOICE_DIR, "voice.md")],
+    ["never-words", join(VOICE_DIR, "never-words.md")],
+    ["non-negotiables", join(VOICE_DIR, "non-negotiables.md")],
+    ["rate-card", join(PLAYBOOK_DIR, "rate-card.md")],
+    ["negotiation", join(PLAYBOOK_DIR, "negotiation.md")],
+  ];
+  const out = [];
+  for (const [kind, file] of files) {
+    const body = readIfExists(file);
+    if (body !== null) out.push({ kind, body });
+  }
+  return out;
+}
+
+/**
+ * Thread metadata for the inbox list. Takes already-fetched threads so this
+ * module never touches Gmail itself — and so the shape of what leaves this
+ * machine is defined in exactly one place, right here.
+ */
+export function collectThreads(threads) {
+  return threads.map((t) => ({
+    threadId: t.id,
+    accountEmail: t.account ?? null,
+    fromName: t.fromName ?? null,
+    fromEmail: t.fromEmail ?? null,
+    subject: t.subject ?? null,
+    lastMessageAt: t.lastMessageAt ?? null,
+    hasUnsentDraft: Boolean(t.hasUnsentDraft),
+  }));
+}
+
+/** The full mirror payload for a complete() call. */
+export function buildMirror({ threads = [] } = {}) {
+  return {
+    threads: collectThreads(threads),
+    deals: collectDeals(),
+    knowledge: collectKnowledge(),
+  };
+}