goosetools-worker 0.1.2 → 0.2.2

package/styles/graph-paper/templates/detail.html

@@ -0,0 +1,56 @@
+<div class="slide detail">
+  <div class="handle">[ {{handle}} ]</div>
+  <div class="kicker">{{subtitle}}</div>
+  <div class="name">{{name}}</div>
+  <div class="body">{{text}}</div>
+  {{ui}}
+</div>
+<style>
+  .detail {
+    {{gridBg}}
+    color: {{colors.textOnLight}};
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    text-align: center;
+  }
+  .detail .handle {
+    align-self: flex-start;
+    font-family: "{{fonts.pixel}}", monospace;
+    text-transform: uppercase;
+    font-weight: 400;
+    font-size: 42px;
+    color: {{colors.primary}};
+  }
+  .detail .handle:empty { display: none; }
+  .detail .kicker {
+    margin-top: 96px;
+    font-family: "{{fonts.pixel}}", monospace;
+    text-transform: uppercase;
+    font-size: 44px;
+    color: {{colors.primary}};
+  }
+  .detail .kicker:empty { display: none; }
+  .detail .name {
+    margin-top: 32px;
+    font-family: "{{fonts.heading}}", serif;
+    font-weight: {{fonts.headingWeight}};
+    font-size: 116px;
+    line-height: 1.05;
+    letter-spacing: -0.01em;
+    color: {{colors.primary}};
+  }
+  .detail .body {
+    margin-top: 72px;
+    margin-bottom: auto;
+    font-family: "{{fonts.mono}}", monospace;
+    font-size: 40px;
+    line-height: 1.65;
+    max-width: 880px;
+    text-align: left;
+    white-space: pre-wrap;
+    color: {{colors.textOnLight}};
+  }
+  .detail .body em { font-style: normal; color: {{colors.primary}}; }
+  .detail .body i { font-style: italic; }
+</style>

package/worker/agent-cli.js

@@ -0,0 +1,275 @@
+// Agent CLI adapter — runs a job's prompt through whichever coding-agent CLI
+// the user picked on goosetools.com (claim payloads carry `agentCli`).
+//
+// VENDORED FILE: keep byte-identical across brand-manager-worker,
+// caption-maker, and carousel-maker (worker/agent-cli.js in each). Fix a bug
+// here, copy it to the other two.
+//
+// Modes, chosen for speed-vs-capability (see brand-manager commit c0c1b33 —
+// tool-looping turned 36-second drafts into 10-minute ones):
+//   "text"    — plain prompt-in/text-out, no tool flags at all (captions).
+//   "oneshot" — tools explicitly OFF, all context inlined by the caller.
+//   "read"    — file-reading allowed (carousel drafts look at photos).
+//   "session" — tools ON and resumable where the CLI supports it.
+//
+// Honest capability notes per CLI:
+//   claude   — full support: fine tool control, JSON envelope, --resume.
+//   codex    — sandbox-level tool control only; resumable threads; JSONL out.
+//   gemini   — no headless resume: sessionId is always null, callers replay
+//              history (they already do this whenever sessionId is absent).
+//   opencode — plain text out; session continuation is version-dependent, so
+//              we don't claim it: sessionId is always null.
+//
+// Session ids are namespaced ("claude:<uuid>", "codex:<thread-id>") because
+// the server stores them per conversation and the user can switch agents
+// between turns — a Claude uuid means nothing to Codex. resolveSession()
+// drops a mismatched id so the caller falls back to history replay. Bare
+// un-prefixed ids predate namespacing and are treated as Claude's.
+
+import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
+
+export const AGENT_IDS = ["claude-code", "codex", "gemini", "opencode"];
+
+const INSTALL_HINTS = {
+  "claude-code": "npm install -g @anthropic-ai/claude-code",
+  codex: "npm install -g @openai/codex, then run: codex login",
+  gemini: "npm install -g @google/gemini-cli, then run: gemini (to sign in)",
+  opencode: "npm install -g opencode-ai, then run: opencode auth login",
+};
+
+const LABELS = {
+  "claude-code": "Claude Code",
+  codex: "Codex CLI",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
+};
+
+// Session-id namespace per agent. claude-code writes "claude:" for continuity
+// with the bare ids already stored server-side.
+const SESSION_PREFIX = {
+  "claude-code": "claude",
+  codex: "codex",
+  gemini: "gemini",
+  opencode: "opencode",
+};
+
+function bin(agent) {
+  if (agent === "claude-code") return process.env.CLAUDE_BIN ?? "claude";
+  return agent; // codex / gemini / opencode binaries share their id
+}
+
+/** "claude" (legacy claim payloads) → "claude-code"; unknown → null. */
+export function normalizeAgent(v) {
+  if (v == null || v === "" ) return "claude-code";
+  if (v === "claude") return "claude-code";
+  return AGENT_IDS.includes(v) ? v : null;
+}
+
+/**
+ * Turn a stored (possibly namespaced, possibly another agent's) session id
+ * into one usable by `agent`, or null — null tells the caller to inline the
+ * conversation history instead of resuming.
+ */
+export function resolveSession(agent, sessionId) {
+  if (!sessionId) return null;
+  const idx = sessionId.indexOf(":");
+  if (idx === -1) {
+    // Legacy bare id — those were always Claude Code session uuids.
+    return agent === "claude-code" ? sessionId : null;
+  }
+  const prefix = sessionId.slice(0, idx);
+  return prefix === SESSION_PREFIX[agent] ? sessionId.slice(idx + 1) : null;
+}
+
+function namespaced(agent, rawId) {
+  return rawId ? `${SESSION_PREFIX[agent]}:${rawId}` : null;
+}
+
+// Strip ANSI escapes and other terminal noise some CLIs print around answers.
+export function cleanText(text) {
+  // eslint-disable-next-line no-control-regex
+  return String(text).replace(/\[[0-9;]*[A-Za-z]/g, "").trim();
+}
+
+// stdio[0] MUST be "ignore". Inherited stdin makes invocations hang forever
+// under launchd — brand-manager hit this exact bug (fixed in 3b1f955) and it
+// presents as the worker silently doing nothing after a reboot.
+function run(agent, args, { timeoutMs, cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin(agent), args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => (stdout += d));
+    child.stderr.on("data", (d) => (stderr += d));
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${LABELS[agent]} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(
+        err.code === "ENOENT"
+          ? new Error(
+              `${LABELS[agent]} isn't installed on this computer. Install: ${INSTALL_HINTS[agent]} — or switch your agent back to Claude Code in Setup on goosetools.com.`,
+            )
+          : err,
+      );
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else
+        reject(
+          new Error(`${LABELS[agent]} exited ${code}: ${stderr.slice(0, 600)}`),
+        );
+    });
+  });
+}
+
+/** Is the CLI on PATH? { installed, hint } — cheap, for startup diagnostics. */
+export function detect(agent) {
+  const res = spawnSync(bin(agent), ["--version"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10_000,
+  });
+  return {
+    installed: res.status === 0,
+    hint: INSTALL_HINTS[agent],
+    label: LABELS[agent],
+  };
+}
+
+// Tools Claude must NOT touch in oneshot mode — everything is inlined.
+const CLAUDE_TOOLS_OFF = "Read,Edit,Write,Bash,Glob,Grep,WebFetch,WebSearch";
+
+/**
+ * Run a prompt through the chosen agent CLI.
+ * Returns { text, sessionId } — sessionId is namespaced and null whenever
+ * the CLI can't resume (callers then replay history on the next turn).
+ */
+export async function runAgent({
+  agent = "claude-code",
+  prompt,
+  cwd,
+  mode = "text",
+  sessionId = null,
+  tools = "Read,Edit,Write,Glob,Grep",
+  timeoutMs = 5 * 60 * 1000,
+}) {
+  const normalized = normalizeAgent(agent);
+  if (!normalized) {
+    throw new Error(
+      `Unknown agent "${agent}" — update this worker: npx --yes <package>@latest install`,
+    );
+  }
+  const resume = resolveSession(normalized, sessionId);
+
+  if (normalized === "claude-code") {
+    if (mode === "session") {
+      const args = [
+        "-p",
+        prompt,
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "acceptEdits",
+        "--allowedTools",
+        tools,
+      ];
+      if (resume) args.push("--resume", resume);
+      const raw = await run(normalized, args, { timeoutMs, cwd });
+      // The json envelope carries the session id. Be forgiving: a shape
+      // change shouldn't lose the user's answer.
+      try {
+        const parsed = JSON.parse(raw);
+        return {
+          text: parsed.result ?? parsed.text ?? raw,
+          sessionId: namespaced(
+            normalized,
+            parsed.session_id ?? parsed.sessionId ?? resume ?? null,
+          ),
+        };
+      } catch {
+        return { text: raw, sessionId: namespaced(normalized, resume) };
+      }
+    }
+    const args = ["-p", prompt, "--output-format", "text"];
+    if (mode === "oneshot") args.push("--disallowedTools", CLAUDE_TOOLS_OFF);
+    if (mode === "read") args.push("--allowedTools", "Read");
+    const text = await run(normalized, args, { timeoutMs, cwd });
+    return { text, sessionId: null };
+  }
+
+  if (normalized === "codex") {
+    // Sandbox is the only tool control codex offers; read-only + the prompt's
+    // own "don't use tools" language is the closest match to oneshot.
+    const sandbox = mode === "session" ? "workspace-write" : "read-only";
+    const args = ["exec"];
+    if (resume) args.push("resume", resume);
+    args.push("--skip-git-repo-check", "--sandbox", sandbox, "--json");
+    if (cwd) args.push("--cd", cwd);
+    args.push(prompt);
+    const raw = await run(normalized, args, { timeoutMs, cwd });
+    // --json emits JSONL events; harvest the thread id and the last agent
+    // message, falling back to the raw output if the shape ever changes.
+    let threadId = resume ?? null;
+    let last = null;
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("{")) continue;
+      try {
+        const evt = JSON.parse(trimmed);
+        threadId =
+          evt.thread_id ?? evt.session_id ?? evt.thread?.id ?? threadId;
+        const item = evt.item ?? evt;
+        const type = item.item_type ?? item.type;
+        if (
+          (type === "agent_message" || type === "assistant_message") &&
+          typeof (item.text ?? item.message) === "string"
+        ) {
+          last = item.text ?? item.message;
+        }
+      } catch {
+        // not an event line — ignore
+      }
+    }
+    return {
+      text: cleanText(last ?? raw),
+      sessionId: mode === "session" ? namespaced(normalized, threadId) : null,
+    };
+  }
+
+  if (normalized === "gemini") {
+    // No reliable headless resume — never claim one. Session mode gets yolo
+    // approvals so its tools can run unattended.
+    const args = ["-p", prompt, "--output-format", "json"];
+    if (mode === "session") args.push("--yolo");
+    let raw;
+    try {
+      raw = await run(normalized, args, { timeoutMs, cwd });
+    } catch (err) {
+      // Older gemini builds lack --output-format; retry plain.
+      if (!/output-format|unknown option/i.test(String(err.message))) throw err;
+      raw = await run(normalized, ["-p", prompt], { timeoutMs, cwd });
+      return { text: cleanText(raw), sessionId: null };
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return {
+        text: cleanText(parsed.response ?? parsed.result ?? raw),
+        sessionId: null,
+      };
+    } catch {
+      return { text: cleanText(raw), sessionId: null };
+    }
+  }
+
+  // opencode — plain text out; we don't claim session continuation (it's
+  // version-dependent), so every turn replays history.
+  const raw = await run(normalized, ["run", prompt], { timeoutMs, cwd });
+  return { text: cleanText(raw), sessionId: null };
+}

package/worker/cli.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 // goosetools-worker entrypoint — makes first run painless for non-technical
 // users: checks for Claude Code + the Playwright browser, installs the
-// browser if missing, then starts the worker loop.
+// browser if missing, then runs the requested command.
+//
+//   install    save token + register a login service (worker runs forever)
+//   update     pull the newest code into the background copy + restart
+//   status     what's installed, whether it's running, recent log lines
+//   uninstall  remove the service + saved token
+//   run        run the worker loop in this window (default)
 
 import { execFileSync, execSync } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -11,6 +17,30 @@ import { fileURLToPath } from "node:url";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
+const command = ["install", "update", "status", "uninstall", "run", "doctor"].includes(process.argv[2])
+  ? process.argv[2]
+  : "run";
+
+// These two only inspect or tear down what's already there, so they skip the
+// Claude Code / browser preflight below — `status` in particular has to work
+// precisely when something IS wrong.
+if (command === "uninstall") {
+  const { uninstall } = await import("./service.js");
+  uninstall();
+  process.exit(0);
+}
+
+if (command === "status") {
+  const { status } = await import("./service.js");
+  status();
+  process.exit(0);
+}
+
+function flag(name) {
+  const i = process.argv.indexOf(name);
+  return i !== -1 ? process.argv[i + 1] : undefined;
+}
+
 function has(cmd) {
   try {
     execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, {
@@ -23,6 +53,20 @@ function has(cmd) {
   }
 }
 
+// Claude Code is the default agent, so it's required to set up; the other
+// agents (picked in Setup on goosetools.com) are checked lazily per job and
+// reported by `doctor`.
+if (command === "doctor") {
+  const { AGENT_IDS, detect } = await import("./agent-cli.js");
+  for (const id of AGENT_IDS) {
+    const d = detect(id);
+    console.log(
+      `${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`,
+    );
+  }
+  process.exit(0);
+}
+
 if (!has("claude")) {
   console.error(
     "\nClaude Code isn't installed yet (it writes your slides).\n" +
@@ -65,4 +109,16 @@ try {
   process.exit(1);
 }
 
-await import("./index.js");
+if (command === "install") {
+  const { install } = await import("./service.js");
+  install({
+    url: (flag("--url") ?? "https://goosetools.com").replace(/\/$/, ""),
+    token: flag("--token"),
+    root: ROOT,
+  });
+} else if (command === "update") {
+  const { update } = await import("./service.js");
+  update({ root: ROOT });
+} else {
+  await import("./index.js");
+}