@trygocode/notify 0.1.0

package/dist/src/status.js

@@ -0,0 +1,150 @@
+// `gocode-notify status` — a coherent at-a-glance report (PRD §4.1, §8):
+//   - credentials present? (and the bound user/label)
+//   - server reachable? (a short, non-blocking probe)
+//   - which agent runtimes are detected on this machine?
+//   - have their config files been written?
+//
+// This module gathers the report into a plain {@link StatusReport} object and
+// renders it human-readably. Keeping the gather/format split lets the later
+// `--agent-driven` task emit the SAME report as JSON without re-collecting it.
+//
+// Runtime detection is delegated to the canonical {@link detectRuntimes} in
+// `detect.ts` (fixture-HOME tested there, PRD §5.2). `status` re-exports the
+// runtime types/table for backward-compatible imports and only consumes the
+// detector to build its summary.
+//
+// Zero runtime deps — Node built-ins only, matching the package's zero-dep rule.
+import { credentialsPath, readCredentials, resolveServerUrl, } from "./creds.js";
+import { detectRuntimes } from "./detect.js";
+// Re-exported so existing `from "./status.js"` imports keep working after the
+// detector moved to its own module.
+export { detectRuntimes, RUNTIMES } from "./detect.js";
+/** Default reachability-probe timeout. Short so `status` never blocks a shell. */
+export const DEFAULT_PROBE_TIMEOUT_MS = 3000;
+/** Health endpoint hit by the reachability probe (any HTTP response = up). */
+export const HEALTH_PATH = "/api/health";
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Probe `${url}${HEALTH_PATH}` to decide reachability. ANY HTTP response (even a
+ * 404) counts as reachable — we only care that the host answered. A network
+ * error or timeout is unreachable. Never throws.
+ */
+export async function probeServer(url, opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(`${url}${HEALTH_PATH}`, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        return { reachable: true, detail: `HTTP ${res.status}` };
+    }
+    catch (err) {
+        const detail = controller.signal.aborted ? `timeout after ${timeoutMs}ms` : errMessage(err);
+        return { reachable: false, detail };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Gather the full {@link StatusReport}. Never throws (collects errors inline). */
+export async function gatherStatus(opts = {}) {
+    const pathOpts = { home: opts.home };
+    // Credentials: distinguish absent (present:false, no error) from malformed
+    // (present:false, error set) so the report can tell the user which to fix.
+    const credsStatus = { present: false, path: credentialsPath(pathOpts) };
+    let creds = null;
+    try {
+        creds = await readCredentials(pathOpts);
+    }
+    catch (err) {
+        credsStatus.error = errMessage(err);
+    }
+    if (creds) {
+        credsStatus.present = true;
+        credsStatus.user_id = creds.user_id;
+        credsStatus.label = creds.label;
+        credsStatus.server = creds.server;
+    }
+    // Server URL via the standard precedence chain (flag > env > creds > default),
+    // then probe it.
+    const url = await resolveServerUrl(opts.serverFlag, pathOpts);
+    const probe = await probeServer(url, { fetchImpl: opts.fetchImpl, timeoutMs: opts.timeoutMs });
+    const runtimes = await detectRuntimes(pathOpts);
+    return {
+        credentials: credsStatus,
+        server: { url, reachable: probe.reachable, detail: probe.detail },
+        runtimes,
+    };
+}
+function mark(ok) {
+    return ok ? "✓" : "✗";
+}
+/** Render a {@link StatusReport} as human-readable lines (one per element). */
+export function formatStatus(report) {
+    const lines = ["gocode-notify status", ""];
+    const c = report.credentials;
+    if (c.present) {
+        lines.push(`${mark(true)} Credentials: paired as ${c.user_id} (${c.label})`);
+    }
+    else if (c.error) {
+        lines.push(`${mark(false)} Credentials: unreadable — ${c.error}`);
+    }
+    else {
+        lines.push(`${mark(false)} Credentials: not paired — run \`gocode-notify login\``);
+    }
+    lines.push(`    path: ${c.path}`);
+    lines.push(`${mark(report.server.reachable)} Server: ${report.server.url} (${report.server.detail})`);
+    lines.push("", "Runtimes:");
+    for (const r of report.runtimes) {
+        if (!r.detected) {
+            lines.push(`  ${mark(false)} ${r.name}: not detected`);
+            continue;
+        }
+        const cfg = r.configWritten ? "config written" : "no config yet";
+        lines.push(`  ${mark(true)} ${r.name}: detected (${cfg})`);
+        lines.push(`      config: ${r.configPath}`);
+    }
+    return lines;
+}
+/**
+ * Render a {@link StatusReport} as `--agent-driven` step lines (PRD §4.4): one
+ * line per report element — `credentials`, `server`, then `runtime:<name>` for
+ * each runtime — so an agent can parse the same report `formatStatus` renders
+ * for humans. `ok` reflects whether that element is in the desired state
+ * (paired / reachable / detected).
+ */
+export function formatStatusSteps(report) {
+    const steps = [];
+    const c = report.credentials;
+    steps.push({
+        step: "credentials",
+        ok: c.present,
+        detail: c.present
+            ? `paired as ${c.user_id} (${c.label})`
+            : c.error
+                ? `unreadable — ${c.error}`
+                : "not paired",
+    });
+    steps.push({
+        step: "server",
+        ok: report.server.reachable,
+        detail: `${report.server.url} (${report.server.detail})`,
+    });
+    for (const r of report.runtimes) {
+        steps.push({
+            step: `runtime:${r.name}`,
+            ok: r.detected,
+            detail: r.detected
+                ? r.configWritten
+                    ? "detected (config written)"
+                    : "detected (no config yet)"
+                : "not detected",
+        });
+    }
+    return steps;
+}

package/dist/src/uninstall.js

@@ -0,0 +1,39 @@
+import { uninstallClaudeConfig, CLAUDE_RUNTIME_NAME, } from "./claude.js";
+import { uninstallCursorConfig, CURSOR_RUNTIME_NAME } from "./cursor.js";
+/** The production runtime uninstallers, in run order. */
+export const defaultUninstallers = [
+    { runtime: CLAUDE_RUNTIME_NAME, run: uninstallClaudeConfig },
+    { runtime: CURSOR_RUNTIME_NAME, run: uninstallCursorConfig },
+];
+/**
+ * Run the uninstall orchestration (PRD §4.1, §11). Resolves (never rejects) to a
+ * {@link UninstallSummary}. Removes exactly our entries from every known runtime,
+ * preserving the user's own config. Idempotent.
+ */
+export async function uninstall(opts = {}) {
+    const pathOpts = { home: opts.home };
+    const runners = opts.uninstallers ?? defaultUninstallers;
+    const runtimes = [];
+    const removed = [];
+    const steps = [];
+    for (const { runtime, run } of runners) {
+        const result = await run(pathOpts);
+        const outcome = { runtime, ...result };
+        runtimes.push(outcome);
+        removed.push(...result.removed);
+        steps.push({
+            step: `uninstall:${runtime}`,
+            ok: !result.failed,
+            detail: result.detail,
+        });
+    }
+    const ok = runtimes.every((r) => !r.failed);
+    steps.push({
+        step: "summary",
+        ok,
+        detail: removed.length > 0
+            ? `removed ${removed.length} gocode-notify entr${removed.length === 1 ? "y" : "ies"}`
+            : "no gocode-notify entries found",
+    });
+    return { ok, runtimes, removed, steps };
+}

package/dist/src/version.js

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

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@trygocode/notify",
+  "version": "0.1.0",
+  "description": "Free phone notifications for any coding agent (Cursor, Claude Code, OpenCode, Ralph/Homer) via the GoCode app. One npx command installs the hooks + MCP server.",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/joseph-lewis/gocode-notify#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joseph-lewis/gocode-notify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/joseph-lewis/gocode-notify/issues"
+  },
+  "author": "GoCode",
+  "bin": {
+    "gocode-notify": "dist/src/cli.js"
+  },
+  "files": [
+    "dist/src",
+    "snippets",
+    "assets",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "tsc -p tsconfig.json",
+    "test": "node --test \"dist/test/**/*.test.js\"",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "notifications",
+    "push",
+    "push-notifications",
+    "fcm",
+    "mcp",
+    "model-context-protocol",
+    "cli",
+    "claude-code",
+    "cursor",
+    "cursor-ide",
+    "hooks",
+    "ai-coding",
+    "opencode",
+    "ralph",
+    "gocode"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.0"
+  }
+}

package/snippets/ralph-homer.sh

@@ -0,0 +1,21 @@
+# gocode-notify — Ralph/Homer loop opt-in snippet  (PRD §5.6, trigger C)
+#
+# OPT-IN. This snippet is NOT auto-injected by `gocode-notify setup`; the
+# installer never edits your loop scripts without consent. Paste these two
+# lines into the completion/halt path of any loop you control (this repo's
+# `ralph`/`homer` skills, Geoffrey Huntley's `while :; do … done` one-liner,
+# or your own driver) to get a phone push when the loop finishes or halts.
+#
+# Prereq: you've already paired this machine once with
+#   npx @trygocode/notify@latest login --code <CODE>
+# (get <CODE> from the GoCode app → "Connect a coding agent").
+#
+# Both lines are fire-and-forget: the `|| true` guarantees a failed/slow push
+# can never block or fail your loop (the CLI also self-times-out in 5s).
+
+# --- At loop completion (the loop finished all work cleanly) -----------------
+gocode-notify send --kind loop_completed --source ralph --project "$(basename "$PWD")" || true
+
+# --- At loop halt (paused_max_failures / awaiting_human / question raised) ---
+gocode-notify send --kind loop_halted --source ralph --project "$(basename "$PWD")" \
+  --title "Ralph halted — needs you" || true