claude-brink 0.1.0

package/src/notify.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// Brink — notifier (Phase 2). CLI-agnostic: `node notify.js "message"` fires a
+// cross-platform phone push (ntfy) + a native desktop toast (Windows-first).
+// Because it's just "send a message", it works from a hook, a daemon, or any caller.
+//
+// Config: reads notify.{ntfy_topic, windows_toast} from $BRINK_DIR/config.json
+// (the documented path — was previously env-only, a review finding). Priority:
+// explicit arg > $BRINK_NTFY > config.json.
+const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function loadNotifyCfg() {
+  try {
+    const dir = process.env.BRINK_DIR || path.join(os.homedir(), '.claude', 'brink');
+    const raw = fs.readFileSync(path.join(dir, 'config.json'), 'utf8');
+    const c = JSON.parse(raw.charCodeAt(0) === 0xFEFF ? raw.slice(1) : raw);
+    return (c && typeof c.notify === 'object' && c.notify) || {};
+  } catch { return {}; }
+}
+
+async function push(topic, msg) {
+  if (!topic || /^REPLACE/.test(topic)) return { push: 'skipped (no ntfy topic)' };
+  try {
+    const res = await fetch(`https://ntfy.sh/${encodeURIComponent(topic)}`, {
+      method: 'POST', body: msg, headers: { Title: 'Brink' },
+    });
+    return { push: `ntfy ${res.status}` };
+  } catch (e) { return { push: 'error: ' + e.message }; }
+}
+
+// Windows toast. NOT detached, and awaited: live-fire testing proved PowerShell 5.1
+// dies at startup when spawned DETACHED_PROCESS (no console), and an attached child
+// dies when the parent's console closes — so the parent must outlive it. notify.js
+// itself is the detached (node survives detachment) fire-and-forget layer, so
+// waiting ~1-2s here blocks nobody. -ExecutionPolicy Bypass: stock Windows ships
+// Restricted, which would silently refuse the .ps1 (review finding).
+function desktop(msg, cfg) {
+  if (os.platform() === 'win32') {
+    if (cfg.windows_toast === false) return Promise.resolve('win-toast-disabled');
+    return new Promise((resolve) => {
+      try {
+        const c = spawn('powershell',
+          ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+            path.join(__dirname, 'notify.ps1'), '-Msg', msg],
+          { stdio: 'ignore', windowsHide: true });
+        const t = setTimeout(() => resolve('win-toast-timeout'), 8000);
+        c.on('error', () => { clearTimeout(t); resolve('win-toast-spawn-error'); });
+        c.on('close', (code) => { clearTimeout(t); resolve(code === 0 ? 'win-toast' : `win-toast-exit-${code}`); });
+      } catch { resolve('win-toast-error'); }
+    });
+  }
+  // TODO Phase 8: macOS (osascript -e 'display notification ...') + Linux (notify-send)
+  return Promise.resolve(`desktop-todo(${os.platform()})`);
+}
+
+async function notify(msg, topic) {
+  if (process.env.BRINK_SILENT) return { silent: true };
+  const cfg = loadNotifyCfg();
+  const [d, p] = await Promise.all([
+    desktop(msg, cfg),
+    push(topic || process.env.BRINK_NTFY || cfg.ntfy_topic || '', msg),
+  ]);
+  return { desktop: d, ...p };
+}
+
+if (require.main === module) {
+  const msg = process.argv.slice(2).join(' ') || 'Brink test notification';
+  notify(msg).then((r) => console.log(JSON.stringify(r)));
+}
+module.exports = { notify };

package/src/notify.ps1

@@ -0,0 +1,13 @@
+# Brink — Windows toast helper (Phase 2). The Windows leaf called by notify.js,
+# which owns cross-platform push (ntfy/Pushover). AppId reuses the Claude.Code path.
+param([string]$Msg)
+
+# native Windows toast
+try {
+  [void][Windows.UI.Notifications.ToastNotificationManager,Windows.UI.Notifications,ContentType=WindowsRuntime]
+  [void][Windows.Data.Xml.Dom.XmlDocument,Windows.Data.Xml.Dom.XmlDocument,ContentType=WindowsRuntime]
+  $x = New-Object Windows.Data.Xml.Dom.XmlDocument
+  $safe = [System.Security.SecurityElement]::Escape($Msg)
+  $x.LoadXml("<toast><visual><binding template='ToastGeneric'><text>Brink</text><text>$safe</text></binding></visual></toast>")
+  [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Claude.Code').Show([Windows.UI.Notifications.ToastNotification]::new($x))
+} catch {}

package/src/resume-once.ps1

@@ -0,0 +1,57 @@
+# Brink - resume once (Phase 7, opt-in)
+# Fires at reset: relaunches Claude headless from HANDOFF.md, then cleans up its task.
+# NOTE: fresh process - continuity depends entirely on HANDOFF.md + the session id.
+param([string]$Sid, [string]$Proj, [int]$Buffer = 90, [string]$Skip = '0')
+
+$taskName = 'BrinkResume_' + ($Sid -replace '[^\w\-]', '_')
+
+# Project gone at fire time? Nothing to resume into - clean up and bail
+# (previously Set-Location failed non-terminating and claude ran in System32).
+if (-not ($Proj -and (Test-Path -LiteralPath $Proj))) {
+  try { & node (Join-Path $PSScriptRoot 'notify.js') "Brink: resume skipped - project folder missing" | Out-Null } catch { }
+  Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue
+  return
+}
+Set-Location -LiteralPath $Proj    # scheduled tasks start in System32 otherwise
+
+# Weekly-cap pre-check: a 5h reset can fire while the 7-day window is still maxed -
+# relaunching would just immediately re-pause. If last-known 7d usage is still at/above
+# the weekly pause threshold, re-arm for the WEEKLY reset instead of relaunching now.
+# (Uses the last state.json; it may be stale, but the 7d window moves slowly.)
+$brinkDir = if ($env:BRINK_DIR) { $env:BRINK_DIR } else { Join-Path $env:USERPROFILE '.claude\brink' }
+$statePath = Join-Path $brinkDir 'state.json'
+if (Test-Path $statePath) {
+  try {
+    $state = Get-Content -LiteralPath $statePath -Raw | ConvertFrom-Json
+    $weeklyPause = 95
+    $cfgPath = Join-Path $brinkDir 'config.json'
+    if (Test-Path $cfgPath) {
+      $cfg = Get-Content -LiteralPath $cfgPath -Raw | ConvertFrom-Json
+      if ($cfg.thresholds.seven_day.pause) { $weeklyPause = [double]$cfg.thresholds.seven_day.pause }
+    }
+    $now = [DateTimeOffset]::UtcNow.ToUnixTimeSeconds()
+    if ($null -ne $state.week_pct -and [double]$state.week_pct -ge $weeklyPause -and
+        $null -ne $state.week_reset -and [int64]$state.week_reset -gt $now) {
+      # forward the user's configured buffer (previously silently reverted to 90)
+      & (Join-Path $PSScriptRoot 'arm-resume.ps1') -ResetsAt ([string]$state.week_reset) -Sid $Sid -Proj $Proj -Buffer $Buffer -Skip $Skip
+      return   # re-armed for the weekly reset; do not relaunch now
+    }
+  } catch { }   # any parse issue -> fall through and just relaunch
+}
+
+$prompt = "Read HANDOFF.md and continue the task from where it was paused. Do not redo finished work."
+if ($Skip -eq '1') {
+  claude --resume $Sid -p $prompt --dangerously-skip-permissions *>> "$Proj/.claude-resume.log"
+} else {
+  claude --resume $Sid -p $prompt *>> "$Proj/.claude-resume.log"
+}
+
+# Self-delete - but ONLY if no future trigger exists: the resumed session may have
+# paused again and re-armed this same task name for the next reset; deleting it here
+# would break resume chaining (review finding).
+try {
+  $t = Get-ScheduledTask -TaskName $taskName -ErrorAction Stop
+  $next = [datetime]::Parse($t.Triggers[0].StartBoundary)
+  if ($next -gt (Get-Date)) { return }   # re-armed during the resumed session - keep it
+} catch { }
+Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction SilentlyContinue

package/src/statusline-brink.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// Brink — sensor + state writer (Phase 1)
+// A Claude Code statusLine command. Reads the usage JSON Claude pipes on stdin,
+// renders a minimal status string, AND atomically writes a tiny state file that
+// the PreToolUse pause hook reads (hooks can't see rate_limits directly).
+//
+// Node-based on purpose: JSON.parse is built in (no jq/python dependency) and it
+// runs anywhere Claude Code runs. State dir overridable via $BRINK_DIR (tests).
+//
+// Install (later phase) as:  "statusLine": { "type": "command",
+//   "command": "node \"<path>/statusline-brink.js\"" }
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const { detectResets } = require('./core/reset');
+
+// Reset-ping defaults (Phase 6): weekly ON, 5h OFF — a 5h reset fires several times
+// a day and trains you to ignore pings; the weekly reset is days of budget coming back.
+// floor = only ping if you were at/above this % before it rolled (else it is noise).
+const DEFAULT_RESET = {
+  five_hour: { enabled: false, floor: 75 },
+  seven_day: { enabled: true,  floor: 80 },
+};
+
+function readJson(p) {
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    return JSON.parse(raw.charCodeAt(0) === 0xFEFF ? raw.slice(1) : raw);
+  } catch { return null; }
+}
+
+function loadResetCfg(dir) {
+  const c = readJson(path.join(dir, 'config.json')) || {};
+  const rp = c.reset_ping || {};
+  return {
+    five_hour: { ...DEFAULT_RESET.five_hour, ...(rp.five_hour || {}) },
+    seven_day: { ...DEFAULT_RESET.seven_day, ...(rp.seven_day || {}) },
+  };
+}
+
+let raw = '';
+process.stdin.on('data', (d) => { raw += d; });
+process.stdin.on('end', () => {
+  let j = {};
+  try { j = JSON.parse(raw || '{}'); } catch { j = {}; }
+
+  const dir = process.env.BRINK_DIR || path.join(os.homedir(), '.claude', 'brink');
+  fs.mkdirSync(dir, { recursive: true });
+
+  // Read last-seen state BEFORE we overwrite it, so a rollover is detectable.
+  const prev = readJson(path.join(dir, 'state.json'));
+
+  const rl = j.rate_limits || {};
+  const five = rl.five_hour || {};
+  const week = rl.seven_day || {};
+  const num = (v) => (typeof v === 'number' ? v : null);
+
+  const fivePct   = num(five.used_percentage);
+  const weekPct   = num(week.used_percentage);
+  const fiveReset = num(five.resets_at);
+  const weekReset = num(week.resets_at);
+  const sid = j.session_id || '';
+  const cwd = (j.workspace && j.workspace.current_dir) || j.cwd || '';
+
+  // --- render (minimal; merge into your full status line) ---
+  let rate = '';
+  if (fivePct !== null) rate = `5h:${Math.round(fivePct)}%`;
+  if (fiveReset !== null) {
+    const left = fiveReset - Math.floor(Date.now() / 1000);
+    if (left > 0) rate += ` (${Math.floor(left / 3600)}h${Math.floor((left % 3600) / 60)}m)`;
+  }
+  if (weekPct !== null) rate += `${rate ? ' * ' : ''}7d:${Math.round(weekPct)}%`;
+  process.stdout.write(rate);
+
+  // --- persist state atomically (write temp + rename) ---
+  const state = {
+    five_pct: fivePct, week_pct: weekPct,
+    five_reset: fiveReset, week_reset: weekReset,
+    session_id: sid, cwd,
+  };
+  // Per-process tmp name: two concurrent Claude sessions share this dir, and a
+  // shared tmp path made ~21% of concurrent refreshes crash on the rename (one
+  // writer renames the tmp away under the other — reproduced live). The rename is
+  // also guarded: Windows throws EPERM if a long-hold reader (AV/indexer) has the
+  // target open, and a lost cycle must not kill the status line.
+  try {
+    const tmp = path.join(dir, `state.json.tmp.${process.pid}`);
+    fs.writeFileSync(tmp, JSON.stringify(state));
+    try {
+      fs.renameSync(tmp, path.join(dir, 'state.json'));
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch {}
+      throw e;
+    }
+  } catch { /* next refresh rewrites; never crash the prompt */ }
+
+  // Reset ping (Phase 6): a window just rolled over -> "your budget is back".
+  // Wrapped so a notifier hiccup can never break the status line. Naturally
+  // debounced: we already wrote the new reset epoch above, so the next refresh
+  // sees no advance and won't re-fire. BRINK_NO_RESET_PING disables for tests.
+  if (!process.env.BRINK_NO_RESET_PING) {
+    try {
+      const events = detectResets(prev, state, { reset_ping: loadResetCfg(dir) });
+      for (const ev of events) {
+        const c = spawn('node', [path.join(__dirname, 'notify.js'), ev.message],
+          { detached: true, stdio: 'ignore', windowsHide: true });
+        c.on('error', () => {}); // async spawn failure must never crash the sensor
+        c.unref();
+      }
+    } catch { /* never let a ping failure break the prompt */ }
+  }
+});