@trygocode/notify 0.6.1 → 0.6.3

package/assets/GoCodeNotifier.app/Contents/_CodeSignature/CodeResources

@@ -8,6 +8,10 @@
 		<data>
 		GbhU1RfeSzs8A7x841vrx8S9NpM=
 		</data>
+		<key>Resources/gocodechime.caf</key>
+		<data>
+		SDZ8imBpH6RxFu4bY6v7z/lR3AE=
+		</data>
 	</dict>
 	<key>files2</key>
 	<dict>
@@ -18,6 +22,13 @@
 			80/V6KfdsY5g+nVZNtqimRwukW+CXDnk+bV0NlYa75w=
 			</data>
 		</dict>
+		<key>Resources/gocodechime.caf</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			l6vi4c8XtFvpGbej45ku/0CP9/B2vPF7hNoUSCQ1kPQ=
+			</data>
+		</dict>
 	</dict>
 	<key>rules</key>
 	<dict>

package/dist/src/cli.js

@@ -20,8 +20,11 @@ import { serveStdio } from "./mcp.js";
 import { setup } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { cmdConfig } from "./config.js";
-import { onStop } from "./on_stop.js";
-import { notifyDesktop, requestDesktopPermission } from "./desktop_notify.js";
+import { onStop, clickTarget, projectLabel } from "./on_stop.js";
+import { notifyDesktop, requestDesktopPermission, desktopDisabledByEnv, } from "./desktop_notify.js";
+import { resolveNotifySettings } from "./config.js";
+import { deriveRepoIdentity } from "./repo_key.js";
+import { decorateTitle, decorateBody } from "./notify_copy.js";
 import { gatherDoctor, formatDoctor } from "./doctor.js";
 /** Subcommands the finished CLI will expose (see PRD §4.1). */
 export const COMMANDS = [
@@ -210,6 +213,98 @@ export async function cmdLogin(args, deps = {}) {
     }
     return 1;
 }
+/**
+ * Fire a branded desktop banner for a `send` (any kind — notably
+ * `awaiting_input` questions and `error`s, which never flow through the
+ * `on-stop` finish dispatcher). This is the parity twin of `on_stop.fireDesktop`
+ * for the plain-`send` path, so EVERY notification the phone gets can also pop on
+ * the computer (PRD §3).
+ *
+ * Behaviour:
+ *   - Resolves this repo's identity + merged settings (60s-TTL cache) so the
+ *     banner is gated on the SAME server-synced `desktop.enabled` as the phone.
+ *   - Skips silently when desktop is disabled, or when even a best-effort banner
+ *     can't be built. NEVER throws, NEVER blocks, NEVER affects the exit code
+ *     (the phone push remains the source of truth).
+ *   - Decorates title/body WORD-FOR-WORD like the phone push via the shared
+ *     {@link decorateTitle}/{@link decorateBody}, and reuses the project label +
+ *     click target (open the IDE for this project) the finish banner uses.
+ *
+ * An explicit `--title`/`--body` on the send wins over the per-kind default
+ * (matching the phone, where an explicit title/body overrides the default copy).
+ */
+export async function fireSendDesktop(payload, deps) {
+    // Hard machine-level opt-out (headless / CI / SSH / tests): bail BEFORE any
+    // settings network call so this path is a true no-op when desktop banners are
+    // disabled for the box. Mirrors `notifyDesktop`'s own env check, but earlier —
+    // so we never even resolve settings (which would otherwise add a fetch the
+    // phone-send unit tests don't expect).
+    if (desktopDisabledByEnv())
+        return undefined;
+    // Resolve repo identity (for the project label + settings scoping + click
+    // target). Best-effort: a derive failure → undefined repo → label falls back
+    // to the cwd basename, exactly like the finish path.
+    const cwd = process.cwd();
+    let repo;
+    try {
+        repo = await deriveRepoIdentity(cwd);
+    }
+    catch {
+        repo = undefined;
+    }
+    // Resolve merged settings for this repo (fail-safe: if nothing is known the
+    // resolver returns conservative defaults, where `desktop` is absent → ON by
+    // default, matching the finish banner's `desktop?.enabled !== false`).
+    let resolved;
+    try {
+        resolved = await resolveNotifySettings({
+            home: deps.home,
+            repo,
+            fetchImpl: deps.fetchImpl,
+            timeoutMs: deps.timeoutMs,
+        });
+    }
+    catch {
+        return undefined;
+    }
+    const settings = resolved.settings;
+    // Gate on the SAME setting as the finish banner (ON by default; only an
+    // explicit `false` silences the computer banner).
+    if (settings.desktop?.enabled === false)
+        return undefined;
+    const source = payload.source;
+    const project = payload.project ?? projectLabel(repo, cwd);
+    // An explicit --title/--body wins (matches the phone send overriding default
+    // copy); otherwise the shared decorators produce the per-kind default folded
+    // with the source label + project, identical to the phone push.
+    const title = payload.title
+        ? payload.title
+        : decorateTitle({ kind: payload.kind, source, project });
+    const body = payload.body
+        ? payload.body
+        : decorateBody({ kind: payload.kind, project });
+    const desktopImpl = deps.notifyDesktopImpl ?? notifyDesktop;
+    try {
+        return await desktopImpl({
+            title,
+            body,
+            kind: payload.kind,
+            sound: settings.desktop?.sound !== false,
+            // Clicking the banner opens the IDE window for THIS project (the agent's
+            // cwd) — same behaviour as the finish banner. Omitted (display-only)
+            // when we can't name the IDE or the path.
+            click: clickTarget(source, cwd),
+        }, {
+            home: deps.home,
+            timeoutMs: deps.timeoutMs,
+            timestamp: deps.timestamp,
+        });
+    }
+    catch {
+        // A desktop banner must never block or fail a send.
+        return undefined;
+    }
+}
 /**
  * Handle `gocode-notify send --kind K [--title T] [--body B] [--source S]
  * [--project P] [--dedupe-key D] [--server URL]`.
@@ -220,6 +315,10 @@ export async function cmdLogin(args, deps = {}) {
  * even on network/server failure, so a hook never blocks the agent's turn. On a
  * delivery failure the payload is queued to the offline outbox; on a successful
  * send the backlog is flushed opportunistically (server is known reachable).
+ *
+ * In parallel with the phone push it fires a branded desktop banner via
+ * {@link fireSendDesktop} (gated on `desktop.enabled`), so questions/errors
+ * raised through `send` pop on the computer too — not just chat finishes.
  */
 export async function cmdSend(args, deps = {}) {
     const flags = parseFlags(args);
@@ -270,7 +369,19 @@ export async function cmdSend(args, deps = {}) {
         timestamp: deps.timestamp,
         server,
     };
-    const result = await send(payload, sendOpts);
+    // Fire the phone push and the branded desktop banner IN PARALLEL so the
+    // computer is told the same instant the phone is (PRD §3) — for EVERY kind
+    // that flows through `send`, notably `awaiting_input` (questions), which the
+    // `on-stop` finish dispatcher never sees. Without this, only chat-FINISH
+    // banners popped on the desktop and questions/errors raised via `send` were
+    // phone-only. The banner is gated on the SAME server-synced `desktop.enabled`
+    // setting as the finish banner, decorated WORD-FOR-WORD identically (same
+    // emoji + source label + project), and is best-effort + total (never throws,
+    // never blocks, never changes the exit code). See {@link fireSendDesktop}.
+    const [result] = await Promise.all([
+        send(payload, sendOpts),
+        fireSendDesktop(payload, deps).catch(() => undefined),
+    ]);
     if (result.ok) {
         // Server is reachable → drain any notifications queued while offline.
         await flush((p) => send(p, sendOpts), deps);

package/dist/src/repo_key.js

@@ -87,8 +87,20 @@ export async function deriveRepoIdentity(cwd = process.cwd(), git = makeGitRunne
     const url = res.code === 0 ? res.stdout.trim() : "";
     const normalized = normalizeRemoteUrl(url);
     if (!normalized) {
-        const base = path.basename(path.resolve(cwd)) || "repo";
-        return { repo_key: `local:${base}`, repo_label: base, synced: false };
+        // `path.basename("/")` is "" (the hook can run with cwd = filesystem root,
+        // e.g. when the IDE spawns it detached without a project cwd). Keep a STABLE
+        // dedup key in that case (`local:repo`) but DON'T surface the meaningless
+        // literal "repo" as the user-facing label — leave `repo_label` EMPTY so the
+        // display layer (`projectLabel`) falls through to its smarter cwd-walk /
+        // omits the project rather than showing "GoCode · repo". (Previously this
+        // hard-coded `|| "repo"` for BOTH the key and the label, which is the cause
+        // of the "repo" project name users saw on root-cwd hook runs.)
+        const base = path.basename(path.resolve(cwd));
+        return {
+            repo_key: `local:${base || "repo"}`,
+            repo_label: base,
+            synced: false,
+        };
     }
     return {
         repo_key: repoKeyFromNormalized(normalized),

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Single source of truth for the CLI version. Keep in sync with package.json.
-export const VERSION = "0.6.1";
+export const VERSION = "0.6.3";

package/package.json

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