brand-manager-worker 0.1.0

package/worker/outreach.js

@@ -0,0 +1,140 @@
+// Brand Outreach handlers: the research chat and the pitch draft.
+//
+// Research (outreach-chat) runs as a resumable Claude session WITH
+// WebSearch/WebFetch — the one job where minutes of tool use is the point.
+// Drafting (outreach-draft) is the fast path: personal layer inlined, tools
+// off, exactly like inbound drafting (brand-manager's 36s lesson).
+//
+// Contact-email doctrine (also enforced server-side): never invent an
+// address; only report one actually seen on a fetched page, with the URL it
+// came from. The pitch is created as a Gmail DRAFT — this package has no
+// send path.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { BASE_DIR, BRAND_DIR, PLAYBOOK_DIR, STATS_DIR, VOICE_DIR } from "./paths.js";
+import { oneShot, parseJson, session } from "./claude.js";
+import { createGmailDraft } from "./gmail-draft.js";
+
+const read = (p, cap = 20_000) =>
+  existsSync(p) ? readFileSync(p, "utf8").slice(0, cap) : "";
+
+/** Base file with the outreach mode instructions (synced from the cloud). */
+const outreachMode = () => read(join(BASE_DIR, "modes", "outreach.md"));
+
+/**
+ * The personal layer for pitch writing, inlined. Order per voice-lookup:
+ * base voice files first, personal mirrors after (personal wins — stated to
+ * the model rather than merged mechanically).
+ */
+function pitchContext() {
+  const parts = [];
+  const add = (label, text) => {
+    if (text.trim()) parts.push(`## ${label}\n\n${text}`);
+  };
+  for (const f of ["never-words.md", "non-negotiables.md", "voice.md"]) {
+    add(`base voice: ${f}`, read(join(BASE_DIR, "voice", f)));
+    add(`PERSONAL voice (wins on conflict): ${f}`, read(join(VOICE_DIR, f)));
+  }
+  add("base playbook: negotiation.md", read(join(BASE_DIR, "playbook", "negotiation.md")));
+  for (const f of existsSync(PLAYBOOK_DIR) ? readdirSync(PLAYBOOK_DIR) : []) {
+    if (f.endsWith(".md")) add(`PERSONAL playbook: ${f}`, read(join(PLAYBOOK_DIR, f)));
+  }
+  add("latest stats snapshot", read(join(STATS_DIR, "latest.md")));
+  return parts.join("\n\n").slice(0, 80_000);
+}
+
+/** Replay for a fresh session when there's no session id to resume. */
+function historyBlock(history) {
+  if (!history?.length) return "";
+  const turns = history
+    .map((h) => `Creator: ${h.instruction ?? ""}\nYou: ${h.body ?? ""}`)
+    .join("\n\n");
+  return `\n## The conversation so far\n\n${turns}\n`;
+}
+
+/**
+ * kind: outreach-chat — research a brand or category online, reply
+ * conversationally, and emit prospect cards as a fenced json block (parsed
+ * out here; the visible reply travels without it).
+ */
+export async function runOutreachChat(job) {
+  const prompt = `${outreachMode()}
+${job.sessionId ? "" : historyBlock(job.history)}
+## This turn
+
+The creator says: "${job.instruction ?? ""}"
+
+Do the research turn as the mode describes. Remember: plain-text reply first,
+then ONE fenced json block with any new prospects (omit the block if none).`;
+
+  const { text, sessionId } = await session(prompt, {
+    cwd: BRAND_DIR,
+    sessionId: job.sessionId ?? null,
+    tools: "WebSearch,WebFetch,Read,Glob,Grep",
+    timeoutMs: 15 * 60 * 1000,
+  });
+
+  const parsed = parseJson(text);
+  const prospects = Array.isArray(parsed?.prospects) ? parsed.prospects : [];
+  // Strip the fenced card block from what the user reads — cards render as UI.
+  const visible = text.replace(/```json\s*[\s\S]*?```/g, "").trim();
+
+  return {
+    ok: true,
+    summary:
+      prospects.length > 0
+        ? `Found ${prospects.length} prospect(s)`
+        : "Replied (no new prospects)",
+    resultBody: visible,
+    prospects,
+    sessionId,
+  };
+}
+
+/**
+ * kind: outreach-draft — write the pitch from the personal layer and create
+ * it as a Gmail draft on a new thread.
+ */
+export async function runOutreachDraft(job) {
+  const prospect = job.payload?.prospect;
+  if (!prospect) return { ok: false, error: "Job carried no prospect card" };
+  if (!prospect.contactEmail)
+    return { ok: false, error: "Prospect has no verified contact email" };
+  if (!job.gmailAccessToken)
+    return { ok: false, error: "Connect Gmail on goosetools.com first" };
+
+  const prompt = `${outreachMode()}
+
+## The creator's layers (personal wins over base on any conflict)
+
+${pitchContext()}
+
+## The prospect
+
+${JSON.stringify(prospect, null, 2)}
+${job.instruction ? `\n## Steering note for this pitch only\n\n${job.instruction}\n` : ""}
+## Your task
+
+Write the outreach pitch email per "The pitch turn" section of the mode.
+Output ONLY a json object, no commentary:
+{"subject": "...", "body": "...", "summary": "one line on the angle you took"}`;
+
+  const text = await oneShot(prompt, { cwd: BRAND_DIR });
+  const decision = parseJson(text);
+  if (!decision?.subject || !decision?.body)
+    return { ok: false, error: "Drafting returned no usable pitch — try again" };
+
+  const gmailDraftId = await createGmailDraft(job.gmailAccessToken, {
+    to: prospect.contactEmail,
+    subject: decision.subject,
+    bodyText: decision.body,
+  });
+
+  return {
+    ok: true,
+    summary: decision.summary ?? `Pitch drafted to ${prospect.brand}`,
+    gmailDraftId,
+    pitchBody: decision.body,
+  };
+}

package/worker/paths.js

@@ -0,0 +1,50 @@
+// The local brand-manager directory — this machine's copy of everything, and
+// the source of truth for it.
+//
+// This mirrors what brand-manager's data/local/ holds today. The website shows
+// a projection of these files; it never owns them. Claude reads and writes them
+// directly, which is why "open Claude Code in this folder and talk to it" keeps
+// working the same way it does in the original repo.
+//
+//   base/       modes + rules + generic voice/playbook, synced down from
+//               Goose Tools. Overwritten on sync — never hand-edit.
+//   voice/      voice.md, never-words.md, non-negotiables.md   (personal)
+//   playbook/   rate-card.md, negotiation.md                   (personal)
+//   deals/      <slug>.md ledgers
+//   stats/      latest.md + screenshots/
+//   drafts.md   append-only log of every drafted body
+//   state.json  processed threads (replaces state/processed.json)
+
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const GOOSE_DIR = join(homedir(), ".goosetools");
+export const BRAND_DIR = join(GOOSE_DIR, "brand-manager");
+
+export const BASE_DIR = join(BRAND_DIR, "base");
+export const VOICE_DIR = join(BRAND_DIR, "voice");
+export const PLAYBOOK_DIR = join(BRAND_DIR, "playbook");
+export const DEALS_DIR = join(BRAND_DIR, "deals");
+export const STATS_DIR = join(BRAND_DIR, "stats");
+export const SCREENSHOTS_DIR = join(STATS_DIR, "screenshots");
+
+export const DRAFTS_LOG = join(BRAND_DIR, "drafts.md");
+export const STATE_FILE = join(BRAND_DIR, "state.json");
+export const ASSETS_VERSION_FILE = join(BASE_DIR, ".version");
+
+/** Create the whole tree. Idempotent — safe on every start. */
+export function ensureDirs() {
+  for (const dir of [
+    BRAND_DIR,
+    BASE_DIR,
+    VOICE_DIR,
+    PLAYBOOK_DIR,
+    DEALS_DIR,
+    STATS_DIR,
+    SCREENSHOTS_DIR,
+  ]) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return BRAND_DIR;
+}

package/worker/service.js

@@ -0,0 +1,347 @@
+// Background-service install/uninstall for the Goose Tools brand worker.
+// Mirrors the carousel worker's installer, but installs alongside it — its own
+// login service + its own background copy — so a computer can run both. The
+// worker TOKEN is shared: both tools read ~/.goosetools/env, so if this
+// computer is already connected (for carousels), `install` needs no --token.
+//
+// `install` makes the brand worker persistent; `update` re-runs it against
+// the newest code; `status` reports what's actually running.
+
+import { execSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const GOOSE_DIR = join(homedir(), ".goosetools");
+const ENV_FILE = join(GOOSE_DIR, "env"); // shared with the carousel worker
+const APP_PREFIX = join(GOOSE_DIR, "brand-app"); // separate from the carousel/caption copies
+const INSTALLED_CLI = join(APP_PREFIX, "node_modules", "brand-manager-worker", "worker", "cli.js");
+
+const MAC_LABEL = "com.goosetools.brand";
+const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+const WIN_TASK = "GooseTools Brand Worker";
+const WIN_VBS = join(GOOSE_DIR, "run-brand-worker.vbs");
+const LOG_FILE = join(GOOSE_DIR, "brand-worker.log");
+const ERR_FILE = join(GOOSE_DIR, "brand-worker.err.log");
+
+function sh(cmd, opts = {}) {
+  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"], ...opts })
+    .toString()
+    .trim();
+}
+
+function quietSh(cmd) {
+  try {
+    sh(cmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function npmGlobalBin() {
+  try {
+    const prefix = sh("npm prefix -g", { shell: true });
+    return process.platform === "win32" ? prefix : join(prefix, "bin");
+  } catch {
+    return "";
+  }
+}
+
+function servicePath() {
+  const parts = [
+    dirname(process.execPath),
+    npmGlobalBin(),
+    ...(process.platform === "win32"
+      ? [process.env.PATH ?? ""]
+      : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]),
+  ].filter(Boolean);
+  return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
+}
+
+function readEnvFile() {
+  if (!existsSync(ENV_FILE)) return {};
+  return Object.fromEntries(
+    readFileSync(ENV_FILE, "utf8")
+      .split("\n")
+      .filter((l) => l.includes("=") && !l.trim().startsWith("#"))
+      .map((l) => [l.slice(0, l.indexOf("=")).trim(), l.slice(l.indexOf("=") + 1).trim()]),
+  );
+}
+
+function writeEnvFile({ url, token }) {
+  mkdirSync(GOOSE_DIR, { recursive: true });
+  writeFileSync(ENV_FILE, `GOOSETOOLS_URL=${url}\nWORKER_TOKEN=${token}\n`);
+  chmodSync(ENV_FILE, 0o600);
+}
+
+function installStableCopy(root) {
+  console.log("Setting up the background copy (this can take a minute)…");
+  mkdirSync(APP_PREFIX, { recursive: true });
+  const source = existsSync(join(root, ".git")) ? `"${root}"` : "brand-manager-worker@latest";
+  execSync(`npm install --no-fund --no-audit --loglevel=error --prefix "${APP_PREFIX}" ${source}`, {
+    stdio: ["ignore", "inherit", "inherit"],
+    shell: true,
+  });
+  if (!existsSync(INSTALLED_CLI)) {
+    throw new Error("background copy did not install where expected");
+  }
+}
+
+// ── macOS (launchd) ──────────────────────────────────────────────────────────
+
+function macPlist() {
+  const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${MAC_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${esc(process.execPath)}</string>
+        <string>${esc(INSTALLED_CLI)}</string>
+        <string>run</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${esc(LOG_FILE)}</string>
+    <key>StandardErrorPath</key>
+    <string>${esc(ERR_FILE)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${esc(servicePath())}</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+
+function macInstall() {
+  mkdirSync(dirname(MAC_PLIST), { recursive: true });
+  writeFileSync(MAC_PLIST, macPlist());
+  const uid = process.getuid();
+  quietSh(`launchctl bootout gui/${uid}/${MAC_LABEL}`);
+  if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
+    quietSh(`launchctl unload "${MAC_PLIST}"`);
+    execSync(`launchctl load -w "${MAC_PLIST}"`, { stdio: "ignore" });
+  }
+}
+
+function macUninstall() {
+  quietSh(`launchctl bootout gui/${process.getuid()}/${MAC_LABEL}`);
+  quietSh(`launchctl unload "${MAC_PLIST}"`);
+  rmSync(MAC_PLIST, { force: true });
+}
+
+// ── Windows (Scheduled Task at logon, hidden window) ─────────────────────────
+
+function winInstall() {
+  const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${INSTALLED_CLI}"" run", 0, False\r\n`;
+  writeFileSync(WIN_VBS, vbs);
+  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
+  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
+  execSync(`schtasks /Create /F /SC ONLOGON /TN "${WIN_TASK}" /TR "wscript.exe \\"${WIN_VBS}\\""`, {
+    stdio: "ignore",
+    shell: true,
+  });
+  execSync(`schtasks /Run /TN "${WIN_TASK}"`, { stdio: "ignore", shell: true });
+}
+
+function winUninstall() {
+  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
+  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
+  rmSync(WIN_VBS, { force: true });
+}
+
+// ── Public commands ──────────────────────────────────────────────────────────
+
+export function install({ url, token, root }) {
+  // The token is shared with the carousel worker — reuse the saved one if the
+  // caller didn't pass --token (a computer already connected for carousels).
+  const saved = readEnvFile();
+  const effectiveToken = token ?? saved.WORKER_TOKEN;
+  const effectiveUrl = url ?? saved.GOOSETOOLS_URL ?? "https://goosetools.com";
+  if (!effectiveToken) {
+    console.error(
+      "No worker token found. Connect this computer at " +
+        effectiveUrl +
+        "/dashboard/brand-manager (or any other tool — same token), then run:\n" +
+        "  npx --yes brand-manager-worker@latest install --token gt_…",
+    );
+    process.exit(1);
+  }
+  writeEnvFile({ url: effectiveUrl, token: effectiveToken });
+  installStableCopy(root);
+  if (process.platform === "darwin") macInstall();
+  else if (process.platform === "win32") winInstall();
+  else {
+    console.error(
+      "Automatic background setup isn't available on this OS yet.\n" +
+        "Run the worker directly instead:  brand-manager-worker run",
+    );
+    process.exit(1);
+  }
+  console.log(
+    "\n✓ All set! This computer now drafts your brand replies in the background —\n" +
+      "  whenever it's on, even after a restart. You can close this window.\n\n" +
+      `  Logs:      ${LOG_FILE}\n` +
+      "  Turn off:  npx --yes brand-manager-worker uninstall\n",
+  );
+}
+
+export function uninstall() {
+  if (process.platform === "darwin") macUninstall();
+  else if (process.platform === "win32") winUninstall();
+  // Only remove this worker's background copy + logs; leave the SHARED env
+  // (and the carousel worker) untouched.
+  rmSync(APP_PREFIX, { recursive: true, force: true });
+  rmSync(LOG_FILE, { force: true });
+  rmSync(ERR_FILE, { force: true });
+  console.log("✓ Brand worker removed. (Your other workers and connection are untouched.)");
+}
+
+export function update({ root }) {
+  const saved = readEnvFile();
+  if (!saved.WORKER_TOKEN) {
+    console.error(
+      "No saved worker token — this computer hasn't been connected yet.\n" +
+        "Connect at https://goosetools.com/dashboard/brand-manager and run:\n" +
+        "  npx --yes brand-manager-worker@latest install --token gt_…",
+    );
+    process.exit(1);
+  }
+  const before = installedVersion();
+  installStableCopy(root);
+  if (process.platform === "darwin") macInstall();
+  else if (process.platform === "win32") winInstall();
+  else {
+    console.error("Automatic background setup isn't available on this OS yet.");
+    process.exit(1);
+  }
+  const after = installedVersion();
+  console.log(
+    after && before && after !== before
+      ? `\n✓ Updated ${before} → ${after} and restarted. Nothing else to do.\n`
+      : `\n✓ Brand worker reinstalled (version ${after ?? "unknown"}) and restarted.\n`,
+  );
+}
+
+// ── status ───────────────────────────────────────────────────────────────────
+function installedVersion() {
+  try {
+    const pkg = join(APP_PREFIX, "node_modules", "brand-manager-worker", "package.json");
+    return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function latestVersion() {
+  try {
+    return sh("npm view brand-manager-worker version", { shell: true, timeout: 15000 });
+  } catch {
+    return null;
+  }
+}
+
+function compareVersions(a, b) {
+  const parts = (v) => String(v).split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [pa, pb] = [parts(a), parts(b)];
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0) ? -1 : 1;
+  }
+  return 0;
+}
+
+function servicePid() {
+  try {
+    if (process.platform === "darwin") {
+      const line = sh(`launchctl list | grep ${MAC_LABEL}`, { shell: true });
+      const pid = line.split(/\s+/)[0];
+      return pid === "-" ? null : pid;
+    }
+    const out = sh(`schtasks /Query /TN "${WIN_TASK}" /FO LIST`, { shell: true });
+    return /Running/i.test(out) ? "running" : null;
+  } catch {
+    return null;
+  }
+}
+
+function tail(file, n) {
+  try {
+    return readFileSync(file, "utf8").trimEnd().split("\n").slice(-n).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+function lastWritten(file) {
+  try {
+    const ms = Date.now() - statSync(file).mtimeMs;
+    const mins = Math.round(ms / 60000);
+    if (mins < 1) return "just now";
+    if (mins < 60) return `${mins} min ago`;
+    const hours = Math.round(mins / 60);
+    if (hours < 24) return `${hours} hr ago`;
+    return `${Math.round(hours / 24)} days ago`;
+  } catch {
+    return "unknown";
+  }
+}
+
+export function status() {
+  const ok = (b) => (b ? "✓" : "✗");
+  const env = readEnvFile();
+  const installed = installedVersion();
+  const latest = latestVersion();
+  const pid = servicePid();
+  const url = env.GOOSETOOLS_URL ?? "https://goosetools.com";
+
+  console.log("\nGoose Tools brand worker — status\n");
+  console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
+  const cmp = installed && latest ? compareVersions(installed, latest) : 0;
+  const stale = cmp < 0;
+  if (latest) {
+    const note = stale ? "  ← update available" : cmp > 0 ? "  (you're ahead — local dev build)" : "";
+    console.log(`  ${ok(!stale)} Latest on npm    ${latest}${note}`);
+  } else {
+    console.log("  · Latest on npm    couldn't check (offline?)");
+  }
+  console.log(`  ${ok(pid)} Running          ${pid ? `yes (pid ${pid})` : "no"}`);
+  console.log(`  ${ok(env.WORKER_TOKEN)} Token saved      ${env.WORKER_TOKEN ? "yes (shared)" : "no — connect a computer first"}`);
+  console.log(`  · Server           ${url}`);
+  console.log(`  · Logs             ${LOG_FILE}`);
+
+  const errors = tail(ERR_FILE, 15);
+  if (errors) {
+    console.log(`\nErrors (last written ${lastWritten(ERR_FILE)}):\n${errors.replace(/^/gm, "  ")}`);
+  }
+  const log = tail(LOG_FILE, 15);
+  if (log) {
+    console.log(`\nActivity (last written ${lastWritten(LOG_FILE)}):\n${log.replace(/^/gm, "  ")}`);
+  }
+
+  if (stale) {
+    console.log("\nTo update:  npx --yes brand-manager-worker@latest update\n");
+  } else if (!pid && installed) {
+    console.log("\nNot running. Restart it with:  npx --yes brand-manager-worker@latest update\n");
+  } else {
+    console.log("");
+  }
+}

package/worker/state.js

@@ -0,0 +1,65 @@
+// Processed-thread state — the dedup that stops the worker re-drafting
+// against the same message every poll. Port of brand-manager's
+// src/core/state.ts, same shape so an imported state file works as-is:
+//
+// { "version": 1,
+//   "threads": { "<threadId>": { lastHandledMessageId, lastDraftAt,
+//                                lastFollowupAt, lastLearnedMessageId } } }
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { STATE_FILE } from "./paths.js";
+
+function load() {
+  if (!existsSync(STATE_FILE)) return { version: 1, threads: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_FILE, "utf8"));
+    return { version: 1, threads: parsed.threads ?? {} };
+  } catch {
+    // A corrupt state file means re-drafting at worst — never crashing.
+    return { version: 1, threads: {} };
+  }
+}
+
+function save(state) {
+  mkdirSync(dirname(STATE_FILE), { recursive: true });
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function entry(state, threadId) {
+  return (state.threads[threadId] ??= {});
+}
+
+export function isHandled(threadId, messageId) {
+  return load().threads[threadId]?.lastHandledMessageId === messageId;
+}
+
+export function markHandled(threadId, messageId) {
+  const state = load();
+  const e = entry(state, threadId);
+  e.lastHandledMessageId = messageId;
+  e.lastDraftAt = new Date().toISOString();
+  save(state);
+}
+
+export function lastFollowupAt(threadId) {
+  return load().threads[threadId]?.lastFollowupAt ?? null;
+}
+
+export function markFollowup(threadId, messageId) {
+  const state = load();
+  const e = entry(state, threadId);
+  e.lastHandledMessageId = messageId;
+  e.lastFollowupAt = new Date().toISOString();
+  save(state);
+}
+
+export function isLearned(threadId, messageId) {
+  return load().threads[threadId]?.lastLearnedMessageId === messageId;
+}
+
+export function markLearned(threadId, messageId) {
+  const state = load();
+  entry(state, threadId).lastLearnedMessageId = messageId;
+  save(state);
+}