roger-roger 0.1.0

package/skills/roger-roger/scripts/herdr.mjs

@@ -0,0 +1,140 @@
+// Herdr (a terminal multiplexer for coding agents) shows every pane in a sidebar as
+// `<directory> <tab label> <agent label>`. Out of the box that reads "code-red 2 claude" — the tab
+// number and the agent's kind — which says nothing about *which* claude, while the user's Slack
+// messages arrive signed "🍯 amber". This closes that gap: when a session runs inside a Herdr pane,
+// its tab is labelled with the session's badge (`🍯 amber`) and its agent with the kind and the work
+// (`claude-build-process-improvements`), so the sidebar and Slack name the same thing.
+//
+// The pane's context comes from the environment Herdr injects into the pane (HERDR_ENV=1 and the
+// ids). The CLI runs there and passes it along with its identity; the daemon, which runs somewhere
+// else entirely, does the renaming with the `herdr` binary against that pane's ids. Renaming is
+// idempotent and repeated only when the nickname or the work changes.
+
+import { spawn } from "node:child_process";
+import { badge } from "./names.mjs";
+
+/** Herdr's own rule for an agent name. */
+const AGENT_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+const MAX_AGENT_NAME = 32;
+const RUN_TIMEOUT_MS = 10_000;
+
+const str = (v) => (typeof v === "string" && v.trim() ? v.trim() : "");
+
+/**
+ * The pane this command runs in, or null outside Herdr. The socket and binary are carried along so
+ * the daemon can reach the same Herdr server from wherever it lives.
+ */
+export function herdrContext(env = process.env) {
+  if (str(env.HERDR_ENV) !== "1") return null;
+  const tab = str(env.HERDR_TAB_ID);
+  const pane = str(env.HERDR_PANE_ID);
+  if (!tab || !pane) return null;
+  return {
+    tab,
+    pane,
+    workspace: str(env.HERDR_WORKSPACE_ID) || null,
+    socket: str(env.HERDR_SOCKET_PATH) || null,
+    bin: str(env.HERDR_BIN_PATH) || null,
+  };
+}
+
+/** What the tab says: the session's badge, `🍯 amber`. */
+export function tabLabel(session) {
+  return session?.nickname ? badge(session.nickname) : "";
+}
+
+/**
+ * What the agent is called: its kind and its work, in the only shape Herdr accepts —
+ * `claude-build-process-improvements`. Without a `--session` name there is nothing to add to what
+ * Herdr already shows (the kind), so the agent is left alone.
+ */
+export function agentName(session) {
+  const work = slug(session?.name);
+  if (!work) return "";
+  const kind = slug(session?.agent) || "agent";
+  const name = `${kind}-${work}`.slice(0, MAX_AGENT_NAME).replace(/[-_]+$/, "");
+  return AGENT_NAME.test(name) ? name : "";
+}
+
+function slug(text) {
+  return String(text ?? "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^[^a-z]+/, "")
+    .replace(/-+$/, "");
+}
+
+/** The labels a session should carry, or null when it isn't in a Herdr pane. */
+export function wantedLabels(session) {
+  if (!session?.herdr?.tab || !session?.herdr?.pane) return null;
+  return { tab: tabLabel(session), agent: agentName(session) };
+}
+
+/** The `herdr` invocations that put those labels on; nothing for a label that is already there. */
+export function labelCommands(session, current = session?.herdrLabel ?? null) {
+  const wanted = wantedLabels(session);
+  if (!wanted) return [];
+  const commands = [];
+  if (wanted.tab && wanted.tab !== current?.tab) commands.push(["tab", "rename", session.herdr.tab, wanted.tab]);
+  if (wanted.agent && wanted.agent !== current?.agent) commands.push(["agent", "rename", session.herdr.pane, wanted.agent]);
+  return commands;
+}
+
+/** Run one `herdr` command. Resolves with its stdout, rejects with what it said on stderr. */
+export function runHerdr(args, { bin = null, socket = null, env = process.env, timeoutMs = RUN_TIMEOUT_MS } = {}) {
+  return new Promise((resolve, reject) => {
+    // Never inherit another pane's context: the ids are explicit, and only the socket matters.
+    const clean = Object.fromEntries(Object.entries(env).filter(([k]) => !k.startsWith("HERDR_")));
+    if (socket) clean.HERDR_SOCKET_PATH = socket;
+    let out = "";
+    let err = "";
+    const child = spawn(bin || "herdr", args, { env: clean, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => child.kill(), timeoutMs);
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", (d) => (err += d));
+    child.on("error", (e) => (clearTimeout(timer), reject(e)));
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve(out);
+      reject(new Error(errorText(err || out) || `herdr ${args.slice(0, 2).join(" ")} exited with ${code}`));
+    });
+  });
+}
+
+/** Herdr's errors are JSON on stderr; the message is the useful part. */
+function errorText(text) {
+  try {
+    return JSON.parse(text)?.error?.message ?? text.trim();
+  } catch {
+    return text.trim();
+  }
+}
+
+const inFlight = new Set();
+
+/**
+ * Put the session's labels on its Herdr pane, if it has one and they are not there yet. Never
+ * throws: a pane that can't be labelled is a line in the log, not a failed command. `touch` records
+ * what was put on, so it isn't done again; `run` is the herdr invocation (replaced in tests).
+ */
+export async function labelPane(session, { log = () => {}, touch = () => {}, run = runHerdr } = {}) {
+  const commands = labelCommands(session);
+  if (!commands.length || inFlight.has(session.id)) return { labelled: false };
+  inFlight.add(session.id);
+  const done = { ...(session.herdrLabel ?? {}) };
+  try {
+    for (const args of commands) {
+      try {
+        await run(args, { bin: session.herdr.bin, socket: session.herdr.socket });
+        done[args[0]] = args[3];
+      } catch (e) {
+        log(`herdr: could not label the ${args[0]} of ${session.nickname} (${args[2]}): ${e.message}`);
+      }
+    }
+    const changed = commands.some((args) => done[args[0]] === args[3]);
+    if (changed) touch(session.id, { herdrLabel: done });
+    return { labelled: changed, label: done };
+  } finally {
+    inFlight.delete(session.id);
+  }
+}

package/skills/roger-roger/scripts/hooks-codex.mjs

@@ -0,0 +1,154 @@
+// Codex's side of the terminal-question ping (see hooks.mjs for the idea).
+//
+// Codex asks the user with its `request_user_input` tool — in Plan mode, or anywhere with its
+// `default_mode_request_user_input` feature — and its hooks see that tool like any other:
+//
+//   PreToolUse   (request_user_input) the question is about to show: note it, wait, ping
+//   PostToolUse  (request_user_input) answered in the terminal: the ping turns into the answer
+//   Interrupt    the turn was cut short, which is how a dismissed question ends: close what's open
+//
+// Codex can't say whether anyone is typing, so the ping waits `terminalWait` seconds first. There
+// is no ping for leave to run a command here: nothing fires when the user answers an approval, so
+// there'd be no telling a prompt still waiting from one approved a second after it showed.
+//
+// Hooks live in ~/.codex/hooks.json, in the same layout as Claude Code's. Codex runs each command
+// through a shell — PowerShell on Windows, sh elsewhere — and won't run a hook until the user has
+// reviewed it in `/hooks`, so installing ends with asking them to do that once.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ourHooks, readSettings, withOurHooks, withoutOurHooks, writeSettings } from "./hooks.mjs";
+
+const str = (v) => (typeof v === "string" ? v.trim() : "");
+const QUESTION_TOOL = "request_user_input";
+const NOTE = /^user_note:\s*/;
+
+/** Codex's questions in the shape the rest of the code reads, keeping each one's id for the answer. */
+function asQuestions(list) {
+  return {
+    questions: (Array.isArray(list) ? list : []).map((q) => ({
+      id: str(q?.id),
+      question: str(q?.question),
+      header: str(q?.header),
+      options: (Array.isArray(q?.options) ? q.options : []).map((o) => ({ label: str(o?.label), description: str(o?.description) })),
+    })),
+  };
+}
+
+/**
+ * The answers, keyed by question text. Codex's tool result is a JSON string of
+ * `{ answers: { <question id>: { answers: ["label", "user_note: …"] } } }`; a note typed with an
+ * answer is kept, in brackets.
+ */
+export function codexAnswers(input, response) {
+  let parsed = response;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return {};
+    }
+  }
+  const byId = parsed?.answers && typeof parsed.answers === "object" ? parsed.answers : {};
+  const answers = {};
+  for (const q of asQuestions(input?.questions).questions) {
+    const given = byId[q.id]?.answers;
+    if (!Array.isArray(given)) continue;
+    const labels = given.map(String).filter((a) => !NOTE.test(a));
+    const notes = given.map(String).filter((a) => NOTE.test(a)).map((a) => a.replace(NOTE, "").trim()).filter(Boolean);
+    answers[q.question] = [labels.join(", "), ...notes.map((n) => `(${n})`)].filter(Boolean).join(" ");
+  }
+  return answers;
+}
+
+/** What Codex sent, as a `permission` command: `{ sessionId, cwd, args, waitFirst }`, or null. */
+export function codexHookRequest(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const sessionId = str(payload.session_id);
+  if (!sessionId) return null;
+  const cwd = str(payload.cwd);
+  const base = { sessionId, cwd };
+  const event = payload.hook_event_name;
+  if (event === "Interrupt") return { ...base, args: { event: "interrupted", cwd } };
+  if (str(payload.tool_name) !== QUESTION_TOOL) return null;
+  const id = str(payload.tool_use_id);
+  if (!id) return null;
+  const input = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {};
+  if (event === "PreToolUse") {
+    return { ...base, args: { event: "request", id, tool: "AskUserQuestion", input: asQuestions(input.questions), cwd }, waitFirst: true };
+  }
+  if (event === "PostToolUse") {
+    // No answers in it means the question never got one: cancelled, or the tool failed.
+    const answers = codexAnswers(input, payload.tool_response);
+    const outcome = Object.keys(answers).length ? "answered" : "dismissed";
+    return { ...base, args: { event: "answered", id, tool: "AskUserQuestion", outcome, response: { answers }, cwd } };
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------- hooks.json
+
+export const codexHome = (env = process.env) => str(env.CODEX_HOME) || path.join(os.homedir(), ".codex");
+export const codexHooksPath = (env = process.env) => path.join(codexHome(env), "hooks.json");
+
+const CODEX_EVENTS = { PreToolUse: QUESTION_TOOL, PostToolUse: QUESTION_TOOL, Interrupt: null };
+
+/** Quoted for sh: single quotes, with any single quote closed, escaped and reopened. */
+const shQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+/** Quoted for PowerShell: single quotes are literal, and a single quote inside is doubled. */
+const psQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+
+/**
+ * Codex runs a hook's command through a shell, so the script path is quoted — for sh in `command`,
+ * and for PowerShell in `commandWindows`, which Codex uses instead on Windows.
+ */
+export function codexHookCommand(script) {
+  const file = script.split(path.sep).join("/");
+  return {
+    type: "command",
+    command: `node ${shQuote(file)} hook codex`,
+    commandWindows: `node ${psQuote(file)} hook codex`,
+    async: true,
+  };
+}
+
+const TRUST = "Codex runs a hook only once you've reviewed it: open Codex, run /hooks, and trust the three roger-roger hooks (again after each reinstall).";
+
+export function codexStatus({ env = process.env, script } = {}) {
+  const file = codexHooksPath(env);
+  const found = ourHooks(readSettings(file));
+  const events = Object.keys(CODEX_EVENTS);
+  const installed = events.every((e) => found[e]);
+  const scripts = [...new Set(Object.values(found).map((f) => f.script))];
+  return {
+    agent: "codex",
+    hooks: file,
+    installed,
+    partial: !installed && events.some((e) => found[e]),
+    found,
+    ...(scripts.length ? { script: scripts[0], scriptExists: scripts.every((s) => s && fs.existsSync(s)) } : {}),
+    ...(installed ? { trust: TRUST } : {}),
+    ...(script && scripts.length && scripts.some((s) => path.resolve(s) !== path.resolve(script)) ? { note: "installed from a different copy of the skill; `hooks install codex` points them at this one" } : {}),
+  };
+}
+
+export function installCodex({ env = process.env, script }) {
+  const file = codexHooksPath(env);
+  const before = readSettings(file);
+  const after = withOurHooks(before, script, { events: CODEX_EVENTS, handler: codexHookCommand });
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) writeSettings(file, after);
+  return { ...codexStatus({ env, script }), changed, ...(changed ? { next: TRUST } : {}) };
+}
+
+export function uninstallCodex({ env = process.env } = {}) {
+  const file = codexHooksPath(env);
+  const before = readSettings(file);
+  const after = withoutOurHooks(before);
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) writeSettings(file, after);
+  // Nothing of anyone's left: no file, rather than one Codex might not accept.
+  if (changed && !Object.keys(after).length) fs.rmSync(file, { force: true });
+  return { ...codexStatus({ env }), changed };
+}

package/skills/roger-roger/scripts/hooks-opencode.mjs

@@ -0,0 +1,167 @@
+// OpenCode's side of the terminal-question ping (see hooks.mjs for the idea).
+//
+// OpenCode has no hook commands; it has plugins — a JS module in its config directory, loaded into
+// the OpenCode process, handed every event on its bus. Ours is a few lines that forward the events
+// we care about to `roger-roger hook opencode`, exactly as Claude Code's hooks run it, so all the
+// deciding happens here and the plugin never needs updating. It also puts the session id in the
+// shell's environment, so the agent's own roger-roger commands land on the same session as the pings.
+//
+//   question.asked      the agent asked something with its question tool: note it, wait, ping
+//   question.replied    answered in the terminal: the ping turns into the answer
+//   question.rejected   dismissed in the terminal
+//   permission.asked    leave to act (pings only with `setup --permission-pings on`)
+//   permission.replied  allowed or denied in the terminal
+//
+// OpenCode can't say whether anyone is typing, so the ping waits `terminalWait` seconds first and
+// goes out only if nothing was answered meanwhile.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const str = (v) => (typeof v === "string" ? v.trim() : "");
+const MARKER = "roger-roger: written by `roger-roger hooks install opencode`";
+
+/** OpenCode's questions in the shape the rest of the code reads (Claude Code's AskUserQuestion). */
+function asQuestions(list) {
+  return {
+    questions: (Array.isArray(list) ? list : []).map((q) => ({
+      question: str(q?.question),
+      header: str(q?.header),
+      options: (Array.isArray(q?.options) ? q.options : []).map((o) => ({ label: str(o?.label), description: str(o?.description) })),
+      multiSelect: Boolean(q?.multiple),
+    })),
+  };
+}
+
+/** A permission as a tool call: OpenCode names permissions after its tools, in lower case. */
+function asToolCall(permission, patterns, metadata) {
+  const first = patterns[0] ?? "";
+  switch (permission) {
+    case "bash":
+      return { tool: "Bash", input: { command: str(metadata.command) || patterns.join("\n"), description: str(metadata.description) } };
+    case "edit":
+    case "write":
+      return { tool: permission === "edit" ? "Edit" : "Write", input: { file_path: str(metadata.filepath) || str(metadata.filePath) || first } };
+    case "read":
+      return { tool: "Read", input: { file_path: str(metadata.filepath) || str(metadata.filePath) || first } };
+    case "webfetch":
+      return { tool: "WebFetch", input: { url: str(metadata.url) || first } };
+    default:
+      return { tool: permission || "permission", input: { patterns } };
+  }
+}
+
+/**
+ * What the plugin forwarded, as a `permission` command: `{ sessionId, cwd, args, waitFirst }`, or
+ * null. `waitFirst` asks the caller to hold on for the user's terminal wait and then ping.
+ */
+export function opencodeHookRequest(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload.properties && typeof payload.properties === "object" ? payload.properties : {};
+  const sessionId = str(p.sessionID);
+  if (!sessionId) return null;
+  const cwd = str(payload.directory);
+  const base = { sessionId, cwd };
+  switch (payload.type) {
+    case "question.asked":
+      if (!str(p.id)) return null;
+      return { ...base, args: { event: "request", id: str(p.id), tool: "AskUserQuestion", input: asQuestions(p.questions), cwd }, waitFirst: true };
+    case "question.replied":
+      return { ...base, args: { event: "answered", id: str(p.requestID), tool: "AskUserQuestion", response: { answers: Array.isArray(p.answers) ? p.answers : [] }, cwd } };
+    case "question.rejected":
+      return { ...base, args: { event: "answered", id: str(p.requestID), tool: "AskUserQuestion", outcome: "dismissed", cwd } };
+    case "permission.asked": {
+      if (!str(p.id)) return null;
+      const patterns = (Array.isArray(p.patterns) ? p.patterns : []).map(String);
+      const metadata = p.metadata && typeof p.metadata === "object" ? p.metadata : {};
+      const { tool, input } = asToolCall(str(p.permission), patterns, metadata);
+      return { ...base, args: { event: "request", id: str(p.id), tool, input, cwd }, waitFirst: true };
+    }
+    case "permission.replied":
+      return { ...base, args: { event: "answered", id: str(p.requestID), outcome: p.reply === "reject" ? "denied" : "allowed", cwd } };
+    default:
+      return null;
+  }
+}
+
+// ---------------------------------------------------------------- the plugin file
+
+/** OpenCode's global config directory: OPENCODE_CONFIG_DIR, else $XDG_CONFIG_HOME or ~/.config. */
+export function opencodeConfigDir(env = process.env) {
+  if (str(env.OPENCODE_CONFIG_DIR)) return str(env.OPENCODE_CONFIG_DIR);
+  return path.join(str(env.XDG_CONFIG_HOME) || path.join(os.homedir(), ".config"), "opencode");
+}
+
+export const opencodePluginPath = (env = process.env) => path.join(opencodeConfigDir(env), "plugins", "roger-roger.js");
+
+/** The plugin, with the script it runs written in. Plain JS, no imports but Node's, no build. */
+export function opencodePlugin(script) {
+  return `// ${MARKER}
+// It forwards OpenCode's question and permission events to roger-roger, which pings you when a
+// question has sat unanswered, and updates the ping once you answer. \`roger-roger hooks uninstall
+// opencode\` deletes this file.
+import { spawn } from "node:child_process";
+
+const SCRIPT = ${JSON.stringify(script.split(path.sep).join("/"))};
+const EVENTS = new Set(["question.asked", "question.replied", "question.rejected", "permission.asked", "permission.replied"]);
+
+function forward(payload) {
+  try {
+    const child = spawn("node", [SCRIPT, "hook", "opencode"], { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
+    child.on("error", () => {});
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify(payload));
+  } catch {
+    // A notification must never get in OpenCode's way.
+  }
+}
+
+export const RogerRoger = async ({ directory }) => ({
+  event: async ({ event }) => {
+    if (EVENTS.has(event?.type)) forward({ type: event.type, properties: event.properties, directory });
+  },
+  // So the agent's own roger-roger commands are recognised as this session.
+  "shell.env": async (input, output) => {
+    if (input?.sessionID && output?.env) output.env.OPENCODE_SESSION_ID = input.sessionID;
+  },
+});
+`;
+}
+
+const scriptIn = (source) => /const SCRIPT = ("(?:[^"\\]|\\.)*");/.exec(source)?.[1];
+
+export function opencodeStatus({ env = process.env, script } = {}) {
+  const file = opencodePluginPath(env);
+  const source = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  const ours = source.includes(MARKER);
+  const installed = ours ? JSON.parse(scriptIn(source) ?? "null") : null;
+  return {
+    agent: "opencode",
+    plugin: file,
+    installed: ours,
+    ...(source && !ours ? { note: "a file of that name exists and isn't ours; it is left alone" } : {}),
+    ...(installed ? { script: installed, scriptExists: fs.existsSync(installed) } : {}),
+    ...(script && installed && path.resolve(installed) !== path.resolve(script) ? { note: "installed from a different copy of the skill; `hooks install opencode` points it at this one" } : {}),
+  };
+}
+
+export function installOpencode({ env = process.env, script }) {
+  const file = opencodePluginPath(env);
+  const source = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  if (source && !source.includes(MARKER)) throw new Error(`${file} exists and wasn't written by roger-roger; move it, then run this again`);
+  const next = opencodePlugin(script);
+  const changed = source !== next;
+  if (changed) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, next, "utf8");
+  }
+  return { ...opencodeStatus({ env, script }), changed, ...(changed ? { restart: "restart OpenCode to load it" } : {}) };
+}
+
+export function uninstallOpencode({ env = process.env } = {}) {
+  const file = opencodePluginPath(env);
+  const ours = fs.existsSync(file) && fs.readFileSync(file, "utf8").includes(MARKER);
+  if (ours) fs.rmSync(file);
+  return { ...opencodeStatus({ env }), changed: ours };
+}