@goodnesshq/opencode-notification 0.1.0

package/plugins/opencode-notifications.mjs

@@ -0,0 +1,690 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { homedir } from "node:os";
+
+const REPO_CONFIG_PATH = ".opencode/oc-notify.json";
+const REPO_SCHEMA_PATH = ".opencode/oc-notify.schema.json";
+const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "oc-notify.json");
+
+const DEFAULTS = {
+  version: 1,
+  enabled: true,
+  title: "",
+  tier: "standard",
+  detailLevel: "full",
+  responseComplete: {
+    enabled: true,
+    trigger: "message.updated",
+  },
+  channels: {
+    mac: {
+      enabled: true,
+      method: "auto",
+    },
+    ntfy: {
+      enabled: true,
+      server: "https://ntfy.sh",
+      topic: "",
+    },
+  },
+  overrides: {
+    includeGroups: [],
+    excludeGroups: [],
+  },
+  dedupe: {
+    ttlSeconds: 60,
+  },
+};
+
+const RESPONSE_TRIGGERS = new Set([
+  "session.idle",
+  "message.updated",
+  "message.part.updated",
+]);
+
+const MAC_METHODS = new Set(["auto", "applescript", "terminal-notifier"]);
+
+const GROUPS = {
+  action_required: ["permission.asked", "question.asked"],
+  responses: ["permission.replied", "question.replied", "question.rejected"],
+  failures: ["session.error", "worktree.failed", "mcp.browser.open.failed", "pty.exited"],
+  change_summary: ["session.diff"],
+  session_lifecycle: ["session.created", "session.compacted"],
+  session_noise: ["session.updated", "session.status"],
+  message_lifecycle: ["message.updated", "message.removed"],
+  message_parts: ["message.part.updated", "message.part.delta", "message.part.removed"],
+  files: ["file.edited", "file.watcher.updated"],
+  todos: ["todo.updated"],
+  vcs_worktree: ["vcs.branch.updated", "worktree.ready"],
+  pty: ["pty.created", "pty.updated", "pty.deleted"],
+  commands_tools: ["command.executed", "mcp.tools.changed"],
+  system: [
+    "installation.update-available",
+    "installation.updated",
+    "project.updated",
+    "server.connected",
+    "server.instance.disposed",
+    "global.disposed",
+  ],
+  lsp: ["lsp.client.diagnostics", "lsp.updated"],
+  tui: ["tui.prompt.append", "tui.command.execute", "tui.toast.show", "tui.session.select"],
+};
+
+const TIER_GROUPS = {
+  minimal: ["action_required", "failures"],
+  standard: ["action_required", "failures", "change_summary", "session_lifecycle"],
+  verbose: [
+    "action_required",
+    "failures",
+    "change_summary",
+    "session_lifecycle",
+    "files",
+    "todos",
+    "vcs_worktree",
+    "pty",
+    "responses",
+  ],
+  custom: [],
+};
+
+const LEVELS = {
+  error: new Set(["session.error", "worktree.failed", "mcp.browser.open.failed", "pty.exited"]),
+  warning: new Set(["permission.asked", "question.asked"]),
+};
+
+const TITLE_LIMIT = 60;
+const SUBTITLE_LIMIT = 80;
+const BODY_LIMIT = 200;
+
+const DEFAULT_TOPIC = "oc-goodness-attn-1407537";
+
+function truncate(value, limit) {
+  if (!value) return "";
+  if (value.length <= limit) return value;
+  return value.slice(0, limit - 1) + "...";
+}
+
+function normalizeString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+
+function normalizeBool(value, fallback) {
+  if (typeof value === "boolean") return value;
+  return fallback;
+}
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+function normalizeTier(value) {
+  if (typeof value !== "string") return DEFAULTS.tier;
+  return TIER_GROUPS[value] ? value : DEFAULTS.tier;
+}
+
+function normalizeTrigger(value) {
+  if (typeof value !== "string") return DEFAULTS.responseComplete.trigger;
+  return RESPONSE_TRIGGERS.has(value) ? value : DEFAULTS.responseComplete.trigger;
+}
+
+function normalizeMacMethod(value) {
+  if (typeof value !== "string") return DEFAULTS.channels.mac.method;
+  return MAC_METHODS.has(value) ? value : DEFAULTS.channels.mac.method;
+}
+
+function sanitizeGroups(groups) {
+  const allowed = new Set(Object.keys(GROUPS));
+  const unique = new Set();
+  for (const group of groups) {
+    if (allowed.has(group)) unique.add(group);
+  }
+  return Array.from(unique);
+}
+
+function normalizeConfig(raw, globalConfig) {
+  const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const globalSource =
+    globalConfig && typeof globalConfig === "object" && !Array.isArray(globalConfig)
+      ? globalConfig
+      : {};
+  const config = {
+    version: DEFAULTS.version,
+    enabled: normalizeBool(source.enabled, DEFAULTS.enabled),
+    title: normalizeString(source.title, DEFAULTS.title),
+    tier: normalizeTier(source.tier),
+    detailLevel: source.detailLevel === "title-only" ? "title-only" : "full",
+    responseComplete: {
+      enabled: normalizeBool(
+        source.responseComplete?.enabled,
+        DEFAULTS.responseComplete.enabled
+      ),
+      trigger: normalizeTrigger(source.responseComplete?.trigger ?? source.responseComplete),
+    },
+    channels: {
+      mac: {
+        enabled: normalizeBool(source.channels?.mac?.enabled, DEFAULTS.channels.mac.enabled),
+        method: normalizeMacMethod(source.channels?.mac?.method),
+      },
+      ntfy: {
+        enabled: normalizeBool(source.channels?.ntfy?.enabled, DEFAULTS.channels.ntfy.enabled),
+        server: normalizeString(
+          source.channels?.ntfy?.server,
+          normalizeString(globalSource.ntfy?.server, DEFAULTS.channels.ntfy.server)
+        ),
+        topic: normalizeString(
+          source.channels?.ntfy?.topic,
+          normalizeString(globalSource.ntfy?.topic, "")
+        ),
+      },
+    },
+    overrides: {
+      includeGroups: sanitizeGroups(normalizeArray(source.overrides?.includeGroups)),
+      excludeGroups: sanitizeGroups(normalizeArray(source.overrides?.excludeGroups)),
+    },
+    dedupe: {
+      ttlSeconds: Number.isFinite(source.dedupe?.ttlSeconds)
+        ? Math.max(0, source.dedupe.ttlSeconds)
+        : DEFAULTS.dedupe.ttlSeconds,
+    },
+  };
+
+  if (!config.channels.ntfy.topic && config.channels.ntfy.enabled) {
+    config.channels.ntfy.topic = DEFAULT_TOPIC;
+  }
+
+  return config;
+}
+
+function buildGroupSet(config) {
+  const baseGroups = TIER_GROUPS[config.tier] ?? TIER_GROUPS.standard;
+  const groupSet = new Set(baseGroups);
+  for (const group of config.overrides.includeGroups) {
+    if (GROUPS[group]) groupSet.add(group);
+  }
+  for (const group of config.overrides.excludeGroups) {
+    groupSet.delete(group);
+  }
+  return groupSet;
+}
+
+function buildEventSet(groupSet) {
+  const events = new Set();
+  for (const group of groupSet) {
+    const groupEvents = GROUPS[group] || [];
+    for (const event of groupEvents) events.add(event);
+  }
+  return events;
+}
+
+function resolveLevel(type) {
+  if (LEVELS.error.has(type)) return "error";
+  if (LEVELS.warning.has(type)) return "warning";
+  return "info";
+}
+
+function extractSessionID(event) {
+  return (
+    event?.properties?.sessionID ||
+    event?.properties?.info?.id ||
+    event?.properties?.info?.sessionID ||
+    event?.properties?.part?.sessionID ||
+    event?.properties?.requestID ||
+    event?.properties?.tool?.sessionID ||
+    ""
+  );
+}
+
+function extractSessionTitle(event) {
+  return normalizeString(event?.properties?.info?.title, "");
+}
+
+function isAssistantMessageComplete(info) {
+  return info?.role === "assistant" && Boolean(info?.time?.completed);
+}
+
+function isStepFinishPart(part) {
+  return part?.type === "step-finish";
+}
+
+function shouldNotifyForEvent(type, event, eventSet, responseConfig) {
+  if (type === "pty.exited" && event?.properties?.exitCode === 0) return false;
+  if (eventSet.has(type)) return true;
+  if (!responseConfig?.enabled) return false;
+  if (responseConfig.trigger === "session.idle" && type === "session.idle") return true;
+  if (responseConfig.trigger === "message.updated" && type === "message.updated") {
+    return isAssistantMessageComplete(event?.properties?.info);
+  }
+  if (responseConfig.trigger === "message.part.updated" && type === "message.part.updated") {
+    return isStepFinishPart(event?.properties?.part);
+  }
+  return false;
+}
+
+function dedupeKey(type, event, responseConfig) {
+  if (type === "permission.asked") return `permission:${event?.properties?.id || ""}`;
+  if (type === "question.asked") return `question:${event?.properties?.id || ""}`;
+  if (type === "session.idle") return `session.idle:${event?.properties?.sessionID || ""}`;
+  if (type === "session.diff") return `session.diff:${event?.properties?.sessionID || ""}`;
+  if (type === "message.updated") {
+    return `message.updated:${event?.properties?.info?.id || ""}`;
+  }
+  if (type === "message.part.updated") {
+    return `message.part.updated:${event?.properties?.part?.id || ""}`;
+  }
+  if (type === "pty.exited") return `pty.exited:${event?.properties?.id || ""}`;
+  if (responseConfig?.trigger === "message.updated" && type === "message.updated") {
+    return `response:${event?.properties?.info?.id || ""}`;
+  }
+  if (responseConfig?.trigger === "message.part.updated" && type === "message.part.updated") {
+    return `response:${event?.properties?.part?.id || ""}`;
+  }
+  if (responseConfig?.trigger === "session.idle" && type === "session.idle") {
+    return `response:${event?.properties?.sessionID || ""}`;
+  }
+  return "";
+}
+
+function buildBody(type, event) {
+  const props = event?.properties || {};
+  switch (type) {
+    case "permission.asked":
+      return `Permission requested: ${props.permission || ""}${props.patterns?.length ? ` for ${props.patterns.join(", ")}` : ""}`.trim();
+    case "question.asked":
+      return props.questions?.[0]?.header ? `Question: ${props.questions[0].header}` : "Question asked";
+    case "permission.replied":
+      return `Permission ${props.reply || "replied"}`;
+    case "question.replied":
+      return "Question answered";
+    case "question.rejected":
+      return "Question dismissed";
+    case "session.idle":
+      return "Assistant finished";
+    case "message.updated":
+      return "Response complete";
+    case "message.part.updated":
+      return "Step finished";
+    case "session.diff": {
+      const diff = props.diff || [];
+      const files = diff.map((item) => item.file).filter(Boolean);
+      const additions = diff.reduce((sum, item) => sum + (item.additions || 0), 0);
+      const deletions = diff.reduce((sum, item) => sum + (item.deletions || 0), 0);
+      const top = files.slice(0, 2).join(", ");
+      return `Changed ${files.length} files (+${additions}/-${deletions}).${top ? ` Top: ${top}` : ""}`;
+    }
+    case "session.error": {
+      const error = props.error || {};
+      const name = error.name || "Error";
+      const message = error.data?.message || "";
+      return message ? `${name}: ${message}` : `${name}`;
+    }
+    case "worktree.failed":
+      return `Worktree failed: ${props.message || ""}`.trim();
+    case "mcp.browser.open.failed":
+      return `Browser open failed: ${props.mcpName || ""}`.trim();
+    case "pty.exited":
+      return `Command failed (exit ${props.exitCode})`;
+    case "vcs.branch.updated":
+      return `Branch: ${props.branch || ""}`.trim();
+    case "worktree.ready":
+      return `Worktree ready: ${props.name || ""}${props.branch ? ` on ${props.branch}` : ""}`.trim();
+    case "file.edited":
+      return `Edited: ${props.file || ""}`.trim();
+    case "file.watcher.updated":
+      return `File ${props.event || ""}: ${props.file || ""}`.trim();
+    case "todo.updated":
+      return `Todos updated: ${(props.todos || []).length} items`;
+    case "command.executed":
+      return `Command executed: ${props.name || ""}`.trim();
+    case "mcp.tools.changed":
+      return `MCP tools changed: ${props.server || ""}`.trim();
+    case "session.created":
+      return "Session started";
+    case "session.compacted":
+      return "Session compacted";
+    case "session.updated":
+      return "Session updated";
+    case "message.removed":
+      return "Message removed";
+    case "message.part.delta":
+      return "Message part updated";
+    case "message.part.removed":
+      return "Message part removed";
+    default:
+      return `OpenCode event: ${type}`;
+  }
+}
+
+async function loadJson(path) {
+  try {
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export default async function opencodeNotify(input) {
+  const { directory, worktree, project, $ } = input;
+  let repoRoot = worktree || directory || project?.worktree || "";
+  const repoNameFallback = project?.name || basename(repoRoot || "");
+  let cachedRepoName = repoNameFallback || "";
+  let cachedBranch = "";
+  let terminalNotifierAvailable = null;
+  let globalConfigCache = { mtime: 0, data: null };
+  let repoConfigCache = { mtime: 0, data: null, errors: [], path: "" };
+  let schemaCache = { mtime: 0, data: null, root: "" };
+  let validationWarned = false;
+  const sessionTitles = new Map();
+  const dedupeStore = new Map();
+
+  async function detectTerminalNotifier() {
+    if (terminalNotifierAvailable !== null) return terminalNotifierAvailable;
+    try {
+      const result = await $`command -v terminal-notifier`.quiet();
+      terminalNotifierAvailable = Boolean(result.stdout.toString().trim());
+    } catch {
+      terminalNotifierAvailable = false;
+    }
+    return terminalNotifierAvailable;
+  }
+
+  async function loadGlobalConfig() {
+    try {
+      const info = await stat(GLOBAL_CONFIG_PATH);
+      if (info.mtimeMs === globalConfigCache.mtime && globalConfigCache.data) {
+        return globalConfigCache.data;
+      }
+      const data = await loadJson(GLOBAL_CONFIG_PATH);
+      globalConfigCache = { mtime: info.mtimeMs, data };
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  async function loadSchema(root) {
+    if (!root) return null;
+    const path = join(root, REPO_SCHEMA_PATH);
+    try {
+      const info = await stat(path);
+      if (info.mtimeMs === schemaCache.mtime && schemaCache.data && schemaCache.root === root) {
+        return schemaCache.data;
+      }
+      const data = await loadJson(path);
+      schemaCache = { mtime: info.mtimeMs, data, root };
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  async function fileExists(path) {
+    try {
+      await stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function resolveRepoRoot() {
+    if (!repoRoot) return "";
+    const direct = join(repoRoot, REPO_CONFIG_PATH);
+    if (await fileExists(direct)) return repoRoot;
+    try {
+      const gitRoot = (await $`git -C ${repoRoot} rev-parse --show-toplevel`.quiet()).stdout
+        .toString()
+        .trim();
+      if (gitRoot && (await fileExists(join(gitRoot, REPO_CONFIG_PATH)))) {
+        repoRoot = gitRoot;
+        return gitRoot;
+      }
+    } catch {}
+    return "";
+  }
+
+  function validateSchema(schema, value, path = "$") {
+    const errors = [];
+    if (!schema || typeof schema !== "object") return errors;
+
+    if (schema.type === "object") {
+      const isObject = value && typeof value === "object" && !Array.isArray(value);
+      if (!isObject) {
+        errors.push(`${path} should be an object`);
+        return errors;
+      }
+      const props = schema.properties || {};
+      if (schema.additionalProperties === false) {
+        for (const key of Object.keys(value)) {
+          if (!props[key]) {
+            errors.push(`${path} has unknown property '${key}'`);
+          }
+        }
+      }
+      for (const [key, childSchema] of Object.entries(props)) {
+        if (value[key] !== undefined) {
+          errors.push(...validateSchema(childSchema, value[key], `${path}.${key}`));
+        }
+      }
+    }
+
+    if (schema.type === "array") {
+      if (!Array.isArray(value)) {
+        errors.push(`${path} should be an array`);
+        return errors;
+      }
+      if (schema.items) {
+        value.forEach((item, index) => {
+          errors.push(...validateSchema(schema.items, item, `${path}[${index}]`));
+        });
+      }
+    }
+
+    if (schema.type === "string") {
+      if (typeof value !== "string") errors.push(`${path} should be a string`);
+    }
+
+    if (schema.type === "number") {
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        errors.push(`${path} should be a number`);
+      }
+    }
+
+    if (schema.type === "integer") {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        errors.push(`${path} should be an integer`);
+      }
+    }
+
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push(`${path} should be one of: ${schema.enum.join(", ")}`);
+    }
+
+    return errors;
+  }
+
+  async function loadRepoConfig() {
+    const root = await resolveRepoRoot();
+    if (!root) return null;
+    const path = join(root, REPO_CONFIG_PATH);
+    try {
+      const info = await stat(path);
+      if (
+        info.mtimeMs === repoConfigCache.mtime &&
+        repoConfigCache.data &&
+        repoConfigCache.path === path
+      ) {
+        return repoConfigCache;
+      }
+      const data = await loadJson(path);
+      const schema = await loadSchema(root);
+      const errors = schema ? validateSchema(schema, data) : [];
+      repoConfigCache = { mtime: info.mtimeMs, data, errors, path };
+      return repoConfigCache;
+    } catch {
+      return null;
+    }
+  }
+
+  async function ensureRepoInfo() {
+    if (cachedRepoName && cachedBranch) return;
+    try {
+      const top = (await $`git -C ${repoRoot} rev-parse --show-toplevel`.quiet()).stdout
+        .toString()
+        .trim();
+      if (top) cachedRepoName = basename(top);
+    } catch {}
+    if (!cachedBranch) {
+      try {
+        cachedBranch = (await $`git -C ${repoRoot} rev-parse --abbrev-ref HEAD`.quiet()).stdout
+          .toString()
+          .trim();
+      } catch {}
+    }
+  }
+
+  function resolveTitle(config) {
+    const repo = cachedRepoName || repoNameFallback;
+    const branch = cachedBranch;
+    const rawTitle = config.title?.trim();
+    let title;
+    if (!rawTitle) {
+      title = branch ? `${repo}@${branch}` : repo;
+    } else if (rawTitle.includes("{repo}") || rawTitle.includes("{branch}")) {
+      title = rawTitle.replaceAll("{repo}", repo).replaceAll("{branch}", branch || "");
+      title = title.replace(/@\s*$/, "").trim();
+    } else {
+      title = rawTitle;
+    }
+    return truncate(title, TITLE_LIMIT);
+  }
+
+  function resolveSubtitle(event) {
+    const sessionID = extractSessionID(event);
+    const title = extractSessionTitle(event);
+    if (title) return truncate(title, SUBTITLE_LIMIT);
+    if (sessionID && sessionTitles.has(sessionID)) {
+      return truncate(sessionTitles.get(sessionID), SUBTITLE_LIMIT);
+    }
+    return truncate(sessionID || "", SUBTITLE_LIMIT);
+  }
+
+  function buildNotification(type, event, config) {
+    const title = resolveTitle(config);
+    const subtitle = resolveSubtitle(event);
+    const level = resolveLevel(type);
+    let body = buildBody(type, event);
+    if (config.detailLevel === "title-only") {
+      body = "";
+    }
+    return {
+      title,
+      subtitle,
+      level,
+      body: truncate(body, BODY_LIMIT),
+    };
+  }
+
+  function shouldDedupe(key, ttlSeconds) {
+    if (!key) return false;
+    const now = Date.now();
+    const ttlMs = ttlSeconds * 1000;
+    const last = dedupeStore.get(key);
+    if (last && now - last < ttlMs) return true;
+    dedupeStore.set(key, now);
+    return false;
+  }
+
+  async function notifyMac(notification, config) {
+    if (!config.channels.mac.enabled) return;
+    try {
+      const method = config.channels.mac.method || "auto";
+      const useTerminalNotifier =
+        method === "terminal-notifier" ||
+        (method === "auto" && (await detectTerminalNotifier()));
+      const message = notification.body || notification.subtitle || "";
+      if (useTerminalNotifier) {
+        await $`terminal-notifier -title ${notification.title} -message ${message} -subtitle ${notification.subtitle}`.quiet();
+        return;
+      }
+      const script = [
+        "on run argv",
+        "set theMessage to item 1 of argv",
+        "set theTitle to item 2 of argv",
+        "set theSubtitle to item 3 of argv",
+        "if theSubtitle is \"\" then",
+        "  display notification theMessage with title theTitle",
+        "else",
+        "  display notification theMessage with title theTitle subtitle theSubtitle",
+        "end if",
+        "end run",
+      ].join("\n");
+      await $`osascript -e ${script} ${message} ${notification.title} ${notification.subtitle}`.quiet();
+    } catch {}
+  }
+
+  async function notifyNtfy(notification, config) {
+    if (!config.channels.ntfy.enabled) return;
+    if (!config.channels.ntfy.topic) return;
+    try {
+      const server = config.channels.ntfy.server.replace(/\/$/, "");
+      const topic = config.channels.ntfy.topic;
+      const url = `${server}/${topic}`;
+      const message = notification.body
+        ? `${notification.subtitle ? `${notification.subtitle}\n` : ""}${notification.body}`
+        : notification.subtitle || notification.title;
+      const tags = ["opencode", notification.level].filter(Boolean).join(",");
+      const priority =
+        notification.level === "error" ? "5" : notification.level === "warning" ? "4" : "3";
+      await $`curl -sS -H ${"Title: " + notification.title} -H ${"Priority: " + priority} -H ${"Tags: " + tags} -d ${message} ${url}`.quiet();
+    } catch {}
+  }
+
+  return {
+    event: async ({ event }) => {
+      const payload = event?.payload ?? event;
+      const eventDirectory = event?.directory;
+      if (eventDirectory) repoRoot = eventDirectory;
+
+      const repoConfig = await loadRepoConfig();
+      if (!repoConfig?.data) return;
+      const globalConfig = await loadGlobalConfig();
+      const config = normalizeConfig(repoConfig.data, globalConfig);
+      if (repoConfig.errors?.length && !validationWarned) {
+        validationWarned = true;
+        console.warn("[opencode-notifications] invalid config detected", repoConfig.errors);
+      }
+      if (!config.enabled) return;
+
+      if (payload?.type === "vcs.branch.updated" && payload?.properties?.branch) {
+        cachedBranch = payload.properties.branch;
+      }
+      if (payload?.type === "session.created" || payload?.type === "session.updated") {
+        const sessionID = extractSessionID(payload);
+        const title = extractSessionTitle(payload);
+        if (sessionID && title) sessionTitles.set(sessionID, title);
+      }
+      if (payload?.type === "session.deleted") {
+        const sessionID = extractSessionID(payload);
+        if (sessionID) sessionTitles.delete(sessionID);
+      }
+
+      await ensureRepoInfo();
+
+      const groupSet = buildGroupSet(config);
+      const eventSet = buildEventSet(groupSet);
+      const type = payload?.type || "unknown";
+      if (!shouldNotifyForEvent(type, payload, eventSet, config.responseComplete)) return;
+
+      const key = dedupeKey(type, payload, config.responseComplete);
+      if (shouldDedupe(key, config.dedupe.ttlSeconds)) return;
+
+      const notification = buildNotification(type, payload, config);
+
+      await notifyMac(notification, config);
+      await notifyNtfy(notification, config);
+    },
+  };
+}
+
+export const OpencodeNotify = opencodeNotify;