@trygocode/notify 0.1.3 → 0.1.4

package/dist/src/on_stop.js

@@ -106,12 +106,12 @@ export async function onStop(opts = {}) {
                 timestamp: opts.timestamp,
                 home: opts.home,
             });
-            await logLine(`auto-push path → ${push.outcome} (settings: ${resolved.source})`);
+            await logLine(`auto-push path → ${push.outcome} (source: ${source}, settings: ${resolved.source})`);
             return { mode: "push", settingsSource: resolved.source, push, repo, detail: push.detail };
         }
         // ── Step 3b: auto-push off → the plain `finished` notification (legacy flow). ──
         if (opts.dryRun) {
-            await logLine(`dry-run: would send finished (auto-push off, settings: ${resolved.source})`);
+            await logLine(`dry-run: would send finished (auto-push off, source: ${source}, settings: ${resolved.source})`);
             return { mode: "dry-run-send", settingsSource: resolved.source, repo };
         }
         const payload = { kind: "finished", source };
@@ -120,7 +120,7 @@ export async function onStop(opts = {}) {
         if (opts.dedupeKey)
             payload.dedupe_key = opts.dedupeKey;
         const sent = await sendImpl(payload);
-        await logLine(`send path → finished ${sent.ok ? "delivered" : "failed"} (settings: ${resolved.source})`);
+        await logLine(`send path → finished ${sent.ok ? "delivered" : "failed"} (source: ${source}, settings: ${resolved.source})`);
         return { mode: "send", settingsSource: resolved.source, send: sent, repo };
     }
     catch (err) {

package/dist/src/opencode.js

@@ -77,33 +77,135 @@ export const OPENCODE_STOP_COMMAND = "npx -y @trygocode/notify on-stop --source
  */
 const PLUGIN_MARKERS = ["gocode-notify", "--source opencode"];
 /**
- * The `session.idle` plugin written to `<config-dir>/plugin/gocode-notify.js`.
+ * Best-effort predicate: does an OpenCode `session.status` payload's `status`
+ * value mean "the agent finished this turn"?
+ *
+ * The `status` value has shifted shape across OpenCode versions — a bare string
+ * (`"idle"`) and an object (`{ type | state | status: "idle" }`). We normalise
+ * to a lowercase string and treat any idle/done/complete/finish word as
+ * end-of-turn, while explicitly REJECTING busy/working/running/active/stream/
+ * pending states so we never ping mid-turn.
+ *
+ * Exported so the generated plugin's behaviour is unit-testable in isolation
+ * (the plugin body inlines the identical logic — keep the two in lockstep; the
+ * `opencode.test.ts` "statusIsIdle parity" test guards against drift).
+ */
+export function opencodeStatusIsIdle(status) {
+    if (status == null)
+        return false;
+    const raw = typeof status === "string"
+        ? status
+        : isRecord(status)
+            ? (status.type ?? status.state ?? status.status ?? "")
+            : "";
+    const s = String(raw).toLowerCase();
+    if (!s)
+        return false;
+    if (s.includes("busy") ||
+        s.includes("work") ||
+        s.includes("run") ||
+        s.includes("active") ||
+        s.includes("stream") ||
+        s.includes("pending")) {
+        return false;
+    }
+    return (s.includes("idle") ||
+        s.includes("done") ||
+        s.includes("complete") ||
+        s.includes("finish"));
+}
+/**
+ * The end-of-turn plugin written to `<config-dir>/plugin/gocode-notify.js`.
+ *
  * An OpenCode plugin exports an async factory returning `{ event }`; we fire the
- * shared `on-stop` dispatcher fire-and-forget on `session.idle`. The child is
- * detached + unref'd with stdio ignored so it NEVER blocks the session, and any
- * spawn error is swallowed (belt-and-braces with the command's own `|| true`).
+ * shared `on-stop` dispatcher fire-and-forget when a session finishes a turn.
+ *
+ * IMPORTANT — why we listen to TWO events:
+ *   - `session.idle` is the original "turn finished" signal, but as of recent
+ *     OpenCode builds (≥ ~1.14) it is **deprecated** and no longer reliably
+ *     emitted in the GUI (upstream moved to `session.status`). Riding it alone
+ *     meant "Cursor pings me, OpenCode doesn't".
+ *   - `session.status` (payload `{ sessionID, status }`) is the modern signal.
+ *     It fires on EVERY status change, so we only treat it as end-of-turn when
+ *     the status is the idle/finished state (best-effort shape detection — the
+ *     `status` value has been a string and an object across versions).
+ *
+ * We subscribe to BOTH so the plugin works on old AND new OpenCode. A small
+ * per-session debounce (DEDUPE_MS) coalesces the idle+status pair for the same
+ * turn so we never spawn `on-stop` twice; the server's `--dedupe-key` is the
+ * second line of defence. The child is detached + unref'd with stdio ignored so
+ * it NEVER blocks the session, and any spawn error is swallowed (belt-and-braces
+ * with the command's own `|| true`).
  */
-export const OPENCODE_PLUGIN_CONTENT = `// gocode-notify — OpenCode session.idle plugin (auto-generated by @trygocode/notify).
+export const OPENCODE_PLUGIN_CONTENT = `// gocode-notify — OpenCode end-of-turn plugin (auto-generated by @trygocode/notify).
 // Fires exactly one fire-and-forget phone notification when an OpenCode session
-// goes idle (the OpenCode equivalent of Claude \`Stop\` / Cursor \`stop\`) by
+// finishes a turn (the OpenCode equivalent of Claude \`Stop\` / Cursor \`stop\`) by
 // shelling out to the shared gocode-notify \`on-stop\` dispatcher. It NEVER blocks
 // the session: the child is detached + unref'd, stdio ignored, errors swallowed.
 //
+// Listens to BOTH \`session.idle\` (legacy, deprecated in newer OpenCode) and
+// \`session.status\` (modern end-of-turn signal). A per-session debounce stops the
+// two from double-firing for the same turn. See tools/gocode-notify/src/opencode.ts.
+//
 // Stable markers (do not edit): gocode-notify --source opencode
 // Managed by @trygocode/notify — \`npx @trygocode/notify uninstall\` removes this file.
 import { spawn } from "node:child_process";
 
+// Per-session last-fire timestamps so idle+status for the SAME turn coalesce.
+const lastFiredAt = new Map();
+const DEDUPE_MS = 4000;
+
+function fire() {
+  try {
+    const child = spawn(
+      ${JSON.stringify(OPENCODE_STOP_COMMAND)},
+      { shell: true, detached: true, stdio: "ignore" },
+    );
+    child.unref();
+  } catch {
+    // never block the session on a notification failure
+  }
+}
+
+// Best-effort: does this \`session.status\` payload mean "the agent finished"?
+// The status value has been a bare string ("idle") and an object ({type|state|
+// status: "idle"}) across OpenCode versions; treat any of those idle-ish shapes
+// as end-of-turn, and explicitly IGNORE busy/working/running states.
+function statusIsIdle(status) {
+  if (status == null) return false;
+  const s = (typeof status === "string"
+    ? status
+    : (status.type ?? status.state ?? status.status ?? "")
+  ).toString().toLowerCase();
+  if (!s) return false;
+  if (s.includes("busy") || s.includes("work") || s.includes("run") ||
+      s.includes("active") || s.includes("stream") || s.includes("pending")) {
+    return false;
+  }
+  return s.includes("idle") || s.includes("done") ||
+         s.includes("complete") || s.includes("finish");
+}
+
+function maybeFire(sessionID) {
+  const key = sessionID || "_";
+  const now = Date.now();
+  const prev = lastFiredAt.get(key) ?? 0;
+  if (now - prev < DEDUPE_MS) return; // coalesce idle+status for one turn
+  lastFiredAt.set(key, now);
+  fire();
+}
+
 export const GocodeNotify = async () => ({
   event: async ({ event }) => {
-    if (!event || event.type !== "session.idle") return;
-    try {
-      const child = spawn(
-        ${JSON.stringify(OPENCODE_STOP_COMMAND)},
-        { shell: true, detached: true, stdio: "ignore" },
-      );
-      child.unref();
-    } catch {
-      // never block the session on a notification failure
+    if (!event) return;
+    const props = event.properties ?? {};
+    if (event.type === "session.idle") {
+      maybeFire(props.sessionID);
+      return;
+    }
+    if (event.type === "session.status") {
+      if (statusIsIdle(props.status)) maybeFire(props.sessionID);
+      return;
     }
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trygocode/notify",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Free phone notifications for any coding agent (Cursor, Claude Code, OpenCode, Ralph/Homer) via the GoCode app.",
   "license": "MIT",
   "type": "module",