@goodnesshq/opencode-notification 0.1.5 → 0.1.6

package/.opencode/notify-init.mjs

@@ -3,6 +3,7 @@ import { readFile, writeFile, mkdir, copyFile, stat } from "node:fs/promises";
 import { join, basename, dirname } from "node:path";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline/promises";
+import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 
 const REPO_CONFIG_PATH = ".opencode/oc-notify.json";
@@ -127,6 +128,246 @@ async function copySchema(cwd) {
   } catch {}
 }
 
+function isInteractive() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  if (process.env.CI) return false;
+  return true;
+}
+
+async function promptInput(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(message);
+  await rl.close();
+  return answer;
+}
+
+function renderPrompt(lines, state) {
+  if (state.linesRendered > 0) {
+    readline.moveCursor(process.stdout, 0, -(state.linesRendered - 1));
+    readline.cursorTo(process.stdout, 0);
+    readline.clearScreenDown(process.stdout);
+  }
+  process.stdout.write(lines.join("\n"));
+  state.linesRendered = lines.length;
+}
+
+async function withRawInput(handler) {
+  const stdin = process.stdin;
+  readline.emitKeypressEvents(stdin);
+  const wasRaw = !!stdin.isRaw;
+  const wasPaused = stdin.isPaused();
+  if (stdin.isTTY) stdin.setRawMode(true);
+  if (wasPaused) stdin.resume();
+  try {
+    return await handler();
+  } finally {
+    if (stdin.isTTY) stdin.setRawMode(wasRaw);
+    if (wasPaused) stdin.pause();
+  }
+}
+
+async function promptSelect({ message, choices, defaultValue }) {
+  return withRawInput(
+    () =>
+      new Promise((resolve) => {
+        const state = { linesRendered: 0 };
+        let cursor = choices.findIndex((choice) => choice.value === defaultValue);
+        if (cursor < 0) cursor = 0;
+
+        const render = () => {
+          const lines = [];
+          lines.push(message);
+          for (let index = 0; index < choices.length; index += 1) {
+            const choice = choices[index];
+            const pointer = index === cursor ? ">" : " ";
+            lines.push(` ${pointer} ${choice.name}`);
+          }
+          renderPrompt(lines, state);
+        };
+
+        const finish = () => {
+          const choice = choices[cursor];
+          const label = choice?.name ?? choice?.value ?? "";
+          renderPrompt([`${message} ${label}`], state);
+          process.stdout.write("\n");
+          cleanup();
+          resolve(choice?.value);
+        };
+
+        const onKey = (_char, key) => {
+          if (!key) return;
+          if (key.ctrl && key.name === "c") {
+            cleanup();
+            process.stdout.write("\n");
+            process.exit(1);
+          }
+          if (key.name === "up") {
+            cursor = Math.max(0, cursor - 1);
+            render();
+            return;
+          }
+          if (key.name === "down") {
+            cursor = Math.min(choices.length - 1, cursor + 1);
+            render();
+            return;
+          }
+          if (key.name === "return" || key.name === "enter") {
+            finish();
+          }
+        };
+
+        const cleanup = () => {
+          process.stdin.removeListener("keypress", onKey);
+        };
+
+        process.stdin.on("keypress", onKey);
+        render();
+      }),
+  );
+}
+
+async function promptConfirm(message, defaultValue) {
+  return promptSelect({
+    message,
+    choices: [
+      { name: "Yes", value: true },
+      { name: "No", value: false },
+    ],
+    defaultValue: defaultValue ? true : false,
+  });
+}
+
+async function promptMultiSelect({
+  message,
+  choices,
+  defaultValues = [],
+  pageSize = 12,
+}) {
+  return withRawInput(
+    () =>
+      new Promise((resolve) => {
+        const state = { linesRendered: 0 };
+        let filter = "";
+        let cursor = 0;
+        const selected = new Set(defaultValues);
+
+        const getFiltered = () => {
+          if (!filter.trim()) return choices;
+          const term = filter.toLowerCase();
+          return choices.filter(
+            (choice) =>
+              choice.name.toLowerCase().includes(term) ||
+              choice.value.toLowerCase().includes(term),
+          );
+        };
+
+        const render = () => {
+          const filtered = getFiltered();
+          if (cursor > Math.max(0, filtered.length - 1)) cursor = 0;
+
+          const lines = [];
+          lines.push(message);
+          lines.push(
+            `Filter: ${filter || "(type to filter)"} (${selected.size} selected)`,
+          );
+
+          if (filtered.length === 0) {
+            lines.push("  No matches");
+            renderPrompt(lines, state);
+            return;
+          }
+
+          const startIndex = Math.max(
+            0,
+            Math.min(
+              cursor - Math.floor(pageSize / 2),
+              Math.max(0, filtered.length - pageSize),
+            ),
+          );
+          const endIndex = Math.min(startIndex + pageSize, filtered.length);
+          const visible = filtered.slice(startIndex, endIndex);
+
+          for (let index = 0; index < visible.length; index += 1) {
+            const actualIndex = startIndex + index;
+            const choice = visible[index];
+            const pointer = actualIndex === cursor ? ">" : " ";
+            const checked = selected.has(choice.value) ? "[x]" : "[ ]";
+            lines.push(` ${pointer} ${checked} ${choice.name}`);
+          }
+
+          renderPrompt(lines, state);
+        };
+
+        const finish = () => {
+          const ordered = choices
+            .filter((choice) => selected.has(choice.value))
+            .map((choice) => choice.value);
+          const summary = ordered.length > 0 ? ordered.join(", ") : "(none)";
+          renderPrompt([`${message} ${summary}`], state);
+          process.stdout.write("\n");
+          cleanup();
+          resolve(ordered);
+        };
+
+        const onKey = (char, key) => {
+          if (!key) return;
+          if (key.ctrl && key.name === "c") {
+            cleanup();
+            process.stdout.write("\n");
+            process.exit(1);
+          }
+          if (key.name === "up") {
+            cursor = Math.max(0, cursor - 1);
+            render();
+            return;
+          }
+          if (key.name === "down") {
+            cursor = Math.min(getFiltered().length - 1, cursor + 1);
+            render();
+            return;
+          }
+          if (key.name === "space") {
+            const filtered = getFiltered();
+            const choice = filtered[cursor];
+            if (choice) {
+              if (selected.has(choice.value)) {
+                selected.delete(choice.value);
+              } else {
+                selected.add(choice.value);
+              }
+              render();
+            }
+            return;
+          }
+          if (key.name === "backspace") {
+            if (filter.length > 0) {
+              filter = filter.slice(0, -1);
+              cursor = 0;
+              render();
+            }
+            return;
+          }
+          if (key.name === "return" || key.name === "enter") {
+            finish();
+            return;
+          }
+          if (char && char.length === 1 && !key.ctrl && !key.meta) {
+            filter += char;
+            cursor = 0;
+            render();
+          }
+        };
+
+        const cleanup = () => {
+          process.stdin.removeListener("keypress", onKey);
+        };
+
+        process.stdin.on("keypress", onKey);
+        render();
+      }),
+  );
+}
+
 
 async function sendTestNotification(config, repoName) {
   const title = config.title || `${repoName}@test`;
@@ -202,121 +443,189 @@ async function main() {
     console.log("Installed .opencode/notify-init.mjs and schema in this repo.");
     return;
   }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const interactive = isInteractive();
+  const rl = interactive ? null : createInterface({ input: process.stdin, output: process.stdout });
 
   console.log("OpenCode Notify — per-repo setup\n");
 
-  const enableInput = await rl.question(
-    "Enable notifications for this repo? (Y/n) [Y] ",
-  );
-  const enabled = yesNo(enableInput, true);
+  const enabled = interactive
+    ? await promptConfirm("Enable notifications for this repo?", true)
+    : yesNo(await rl.question("Enable notifications for this repo? (Y/n) [Y] "), true);
   if (!enabled) {
-    await rl.close();
+    if (rl) await rl.close();
     return;
   }
 
-  const titleInput = await rl.question(
-    `Notification title (blank = "${repoName}@<branch>"): `,
-  );
+  const titleInput = interactive
+    ? await promptInput(`Notification title (blank = "${repoName}@<branch>"): `)
+    : await rl.question(`Notification title (blank = "${repoName}@<branch>"): `);
   const title = titleInput.trim();
 
-  console.log(
-    "\nSelect a tier:\n  1) Minimal\n  2) Standard\n  3) Verbose\n  4) Custom",
-  );
-  const tierInput = await rl.question("> [2] ");
-  const tier =
-    tierInput.trim() === "1"
-      ? "minimal"
-      : tierInput.trim() === "3"
-        ? "verbose"
-        : tierInput.trim() === "4"
-          ? "custom"
-          : "standard";
-
-  console.log(
-    "\nResponse-complete trigger:\n  1) session.idle (coarse, low noise)\n  2) message.updated (precise)\n  3) message.part.updated (very precise, more noise)",
-  );
-  const triggerInput = await rl.question("> [2] ");
-  const trigger =
-    triggerInput.trim() === "1"
-      ? "session.idle"
-      : triggerInput.trim() === "3"
-        ? "message.part.updated"
-        : "message.updated";
-
-  const macInput = await rl.question(
-    "\nEnable macOS Notification Center? (Y/n) [Y] ",
-  );
-  const macEnabled = yesNo(macInput, true);
+  const tier = interactive
+    ? await promptSelect({
+        message: "Select a tier:",
+        choices: [
+          { name: "Minimal", value: "minimal" },
+          { name: "Standard", value: "standard" },
+          { name: "Verbose", value: "verbose" },
+          { name: "Custom", value: "custom" },
+        ],
+        defaultValue: "standard",
+      })
+    : await (async () => {
+        console.log(
+          "\nSelect a tier:\n  1) Minimal\n  2) Standard\n  3) Verbose\n  4) Custom",
+        );
+        const tierInput = await rl.question("> [2] ");
+        return tierInput.trim() === "1"
+          ? "minimal"
+          : tierInput.trim() === "3"
+            ? "verbose"
+            : tierInput.trim() === "4"
+              ? "custom"
+              : "standard";
+      })();
+
+  const trigger = interactive
+    ? await promptSelect({
+        message: "Response-complete trigger:",
+        choices: [
+          { name: "session.idle (coarse, low noise)", value: "session.idle" },
+          { name: "message.updated (precise)", value: "message.updated" },
+          {
+            name: "message.part.updated (very precise, more noise)",
+            value: "message.part.updated",
+          },
+        ],
+        defaultValue: "message.updated",
+      })
+    : await (async () => {
+        console.log(
+          "\nResponse-complete trigger:\n  1) session.idle (coarse, low noise)\n  2) message.updated (precise)\n  3) message.part.updated (very precise, more noise)",
+        );
+        const triggerInput = await rl.question("> [2] ");
+        return triggerInput.trim() === "1"
+          ? "session.idle"
+          : triggerInput.trim() === "3"
+            ? "message.part.updated"
+            : "message.updated";
+      })();
+
+  const macEnabled = interactive
+    ? await promptConfirm("Enable macOS Notification Center?", true)
+    : yesNo(
+        await rl.question(
+          "\nEnable macOS Notification Center? (Y/n) [Y] ",
+        ),
+        true,
+      );
 
-  const ntfyInput = await rl.question("Enable ntfy notifications? (Y/n) [Y] ");
-  const ntfyEnabled = yesNo(ntfyInput, true);
+  const ntfyEnabled = interactive
+    ? await promptConfirm("Enable ntfy notifications?", true)
+    : yesNo(await rl.question("Enable ntfy notifications? (Y/n) [Y] "), true);
 
   let globalConfig = await readJson(GLOBAL_CONFIG_PATH);
   if (!globalConfig) globalConfig = {};
   if (!globalConfig.ntfy) globalConfig.ntfy = {};
 
   if (ntfyEnabled) {
-    const serverInput = await rl.question(
-      `ntfy server (blank = ${globalConfig.ntfy.server || DEFAULTS.channels.ntfy.server}): `,
-    );
+    const serverInput = interactive
+      ? await promptInput(
+          `ntfy server (blank = ${globalConfig.ntfy.server || DEFAULTS.channels.ntfy.server}): `,
+        )
+      : await rl.question(
+          `ntfy server (blank = ${globalConfig.ntfy.server || DEFAULTS.channels.ntfy.server}): `,
+        );
     const topicDefault = globalConfig.ntfy.topic || DEFAULTS.channels.ntfy.topic;
     const topicLabel = topicDefault || "<your-topic>";
-    const topicInput = await rl.question(
-      `ntfy topic (blank = ${topicLabel}; see docs/ntfy-topic.md): `,
-    );
+    const topicInput = interactive
+      ? await promptInput(
+          `ntfy topic (blank = ${topicLabel}; see docs/ntfy-topic.md): `,
+        )
+      : await rl.question(
+          `ntfy topic (blank = ${topicLabel}; see docs/ntfy-topic.md): `,
+        );
     if (serverInput.trim()) globalConfig.ntfy.server = serverInput.trim();
     if (topicInput.trim()) globalConfig.ntfy.topic = topicInput.trim();
   }
 
-  const detailInput = await rl.question(
-    "Detail level (1=full, 2=title-only) [1] ",
-  );
-  const detailLevel = detailInput.trim() === "2" ? "title-only" : "full";
-
-  const adjustGroups = yesNo(
-    await rl.question("\nAdjust event groups? (y/N) [N] "),
-    false,
-  );
+  const detailLevel = interactive
+    ? await promptSelect({
+        message: "Detail level:",
+        choices: [
+          { name: "full", value: "full" },
+          { name: "title-only", value: "title-only" },
+        ],
+        defaultValue: "full",
+      })
+    : (await rl.question("Detail level (1=full, 2=title-only) [1] ")).trim() === "2"
+      ? "title-only"
+      : "full";
+
+  const adjustGroups = interactive
+    ? await promptConfirm("Adjust event groups?", false)
+    : yesNo(await rl.question("\nAdjust event groups? (y/N) [N] "), false);
   let includeGroups = [];
   let excludeGroups = [];
   if (adjustGroups) {
-    const advanced = yesNo(
-      await rl.question("Show advanced groups? (y/N) [N] "),
-      false,
-    );
+    const advanced = interactive
+      ? await promptConfirm("Show advanced groups?", false)
+      : yesNo(await rl.question("Show advanced groups? (y/N) [N] "), false);
     const allowed = advanced
       ? GROUPS_BASIC.concat(GROUPS_ADVANCED)
       : GROUPS_BASIC;
-    console.log(`Available groups: ${allowed.join(", ")}`);
-    const includeInput = await rl.question(
-      "Include groups (comma-separated, blank to skip): ",
-    );
-    const excludeInput = await rl.question(
-      "Exclude groups (comma-separated, blank to skip): ",
-    );
-    includeGroups = parseList(includeInput, allowed);
-    excludeGroups = parseList(excludeInput, allowed);
+    if (interactive) {
+      const choices = allowed.map((group) => ({ name: group, value: group }));
+      includeGroups = await promptMultiSelect({
+        message: "Include groups:",
+        choices,
+        defaultValues: [],
+      });
+      excludeGroups = await promptMultiSelect({
+        message: "Exclude groups:",
+        choices,
+        defaultValues: [],
+      });
+    } else {
+      console.log(`Available groups: ${allowed.join(", ")}`);
+      const includeInput = await rl.question(
+        "Include groups (comma-separated, blank to skip): ",
+      );
+      const excludeInput = await rl.question(
+        "Exclude groups (comma-separated, blank to skip): ",
+      );
+      includeGroups = parseList(includeInput, allowed);
+      excludeGroups = parseList(excludeInput, allowed);
+    }
   }
 
-  const installTN = yesNo(
-    await rl.question("\nUse terminal-notifier if available? (Y/n) [Y] "),
-    true,
-  );
+  const installTN = interactive
+    ? await promptConfirm("Use terminal-notifier if available?", true)
+    : yesNo(
+        await rl.question(
+          "\nUse terminal-notifier if available? (Y/n) [Y] ",
+        ),
+        true,
+      );
 
   if (installTN) {
     const hasTN = await commandExists("terminal-notifier");
     const hasBrew = await commandExists("brew");
     if (!hasTN && hasBrew) {
-      const installNow = yesNo(
-        await rl.question(
-          "terminal-notifier not found. Install with Homebrew now? (y/N) [N] ",
-        ),
-        false,
-      );
-      if (installNow) {
-        try {
-          const { execSync } = await import("node:child_process");
+        const installNow = interactive
+          ? await promptConfirm(
+              "terminal-notifier not found. Install with Homebrew now?",
+              false,
+            )
+          : yesNo(
+              await rl.question(
+                "terminal-notifier not found. Install with Homebrew now? (y/N) [N] ",
+              ),
+              false,
+            );
+        if (installNow) {
+          try {
+            const { execSync } = await import("node:child_process");
           execSync("brew install terminal-notifier", { stdio: "inherit" });
         } catch {
           console.log("Homebrew install failed. Falling back to AppleScript.");
@@ -352,25 +661,28 @@ async function main() {
     },
   };
 
-  const writeInput = await rl.question(
-    "\nWrite config to .opencode/oc-notify.json? (Y/n) [Y] ",
-  );
-  const shouldWrite = yesNo(writeInput, true);
+  const shouldWrite = interactive
+    ? await promptConfirm("Write config to .opencode/oc-notify.json?", true)
+    : yesNo(
+        await rl.question(
+          "\nWrite config to .opencode/oc-notify.json? (Y/n) [Y] ",
+        ),
+        true,
+      );
   if (shouldWrite) {
     await ensureOpencodeDir(cwd);
     await writeJson(join(cwd, REPO_CONFIG_PATH), config);
     await copySchema(cwd);
   }
 
-  const testInput = await rl.question(
-    "Send a test notification now? (Y/n) [Y] ",
-  );
-  const sendTest = yesNo(testInput, true);
+  const sendTest = interactive
+    ? await promptConfirm("Send a test notification now?", true)
+    : yesNo(await rl.question("Send a test notification now? (Y/n) [Y] "), true);
   if (sendTest) {
     await sendTestNotification(config, repoName);
   }
 
-  await rl.close();
+  if (rl) await rl.close();
 }
 
 await main();

package/README.md

@@ -24,19 +24,7 @@ npx @goodnesshq/opencode-notification install
 This only installs repo assets and prints next steps for manual setup.
 
 Before running the installer, create a unique ntfy topic and set up mobile notifications. See `docs/ntfy-topic.md`.
-
-### Update guidance
-
-- One-off: `npx @goodnesshq/opencode-notification@latest setup`
-- Global: `npm update -g @goodnesshq/opencode-notification`
-
-## Troubleshooting
-
-**OpenCode fails to start after enabling the plugin**
-
-- Ensure every entry in `plugin` points to an existing file.
-- Remove stale plugin paths from other repos.
-- Use absolute paths (no `~`).
+The installer uses an interactive, arrow-key prompt flow (with a non-interactive fallback in non-TTY environments).
 
 ## Config Schema
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodnesshq/opencode-notification",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Per-repo notification plugin for OpenCode with macOS and ntfy delivery.",
   "type": "module",
   "bin": {