shraga 0.0.3 → 0.1.2

package/src/server/push/fcm.ts

@@ -0,0 +1,108 @@
+// FCM (Android) sender — HTTP v1 with a Google service-account OAuth token.
+// HTTP only, no firebase-admin SDK (house rule). Same SA → OAuth pattern as
+// mcp-firebase / mcp-google-drive. Ported from appwrap/examples/push-relay.
+import { createSign } from 'node:crypto';
+import type { PushMessage } from './apns.ts';
+
+const env = (k: string) => process.env[k] || '';
+
+export interface FcmResult {
+  status: number;
+  reason?: string;
+}
+
+interface ServiceAccount {
+  client_email: string;
+  private_key: string;
+  project_id?: string;
+}
+
+function loadServiceAccount(): ServiceAccount | null {
+  const raw = env('FCM_SERVICE_ACCOUNT_JSON')
+    || (env('FCM_SERVICE_ACCOUNT_B64') ? Buffer.from(env('FCM_SERVICE_ACCOUNT_B64'), 'base64').toString('utf8') : '');
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as ServiceAccount;
+  } catch (err) {
+    console.error('[push] FCM service account parse failed:', err);
+    return null;
+  }
+}
+
+/** True when FCM credentials are present (independent of PUSH_ENABLED). */
+export function fcmConfigured(): boolean {
+  return !!loadServiceAccount();
+}
+
+function projectId(sa: ServiceAccount): string {
+  return env('FCM_PROJECT_ID') || sa.project_id || '';
+}
+
+const b64url = (o: object) => Buffer.from(JSON.stringify(o)).toString('base64url');
+
+// ── OAuth access token from the SA JWT (RS256), cached < 50min ──
+let tokCache: { tok: string; at: number } | null = null;
+async function accessToken(sa: ServiceAccount): Promise<string | null> {
+  if (tokCache && Date.now() - tokCache.at < 50 * 60_000) return tokCache.tok;
+  const iat = Math.floor(Date.now() / 1000);
+  const head = b64url({ alg: 'RS256', typ: 'JWT' });
+  const claim = b64url({
+    iss: sa.client_email,
+    scope: 'https://www.googleapis.com/auth/firebase.messaging',
+    aud: 'https://oauth2.googleapis.com/token',
+    iat,
+    exp: iat + 3600,
+  });
+  const sig = createSign('RSA-SHA256').update(`${head}.${claim}`).sign(sa.private_key).toString('base64url');
+  const res = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${head}.${claim}.${sig}`,
+  }).catch((err) => { console.error('[push] FCM oauth fetch failed:', err); return null; });
+  if (!res || !res.ok) {
+    if (res) console.error('[push] FCM oauth rejected:', res.status, (await res.text()).slice(0, 200));
+    return null;
+  }
+  const j = (await res.json()) as { access_token?: string };
+  if (!j.access_token) return null;
+  tokCache = { tok: j.access_token, at: Date.now() };
+  return j.access_token;
+}
+
+// FCM data fields must be string→string.
+function stringifyData(data?: Record<string, unknown>): Record<string, string> | undefined {
+  if (!data) return undefined;
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(data)) out[k] = typeof v === 'string' ? v : JSON.stringify(v);
+  return out;
+}
+
+/** 404 (NOT_FOUND) or an UNREGISTERED error → the token is dead and should be pruned. */
+export function isFcmTokenDead(status: number, reason?: string): boolean {
+  if (status === 404) return true;
+  return !!reason && /UNREGISTERED|registration-token-not-registered/i.test(reason);
+}
+
+export async function sendFcm(token: string, msg: PushMessage): Promise<FcmResult> {
+  const sa = loadServiceAccount();
+  if (!sa) return { status: 0, reason: 'no_service_account' };
+  const pid = projectId(sa);
+  if (!pid) return { status: 0, reason: 'no_project_id' };
+  const at = await accessToken(sa);
+  if (!at) return { status: 0, reason: 'no_access_token' };
+
+  const res = await fetch(`https://fcm.googleapis.com/v1/projects/${pid}/messages:send`, {
+    method: 'POST',
+    headers: { authorization: `Bearer ${at}`, 'content-type': 'application/json' },
+    body: JSON.stringify({
+      message: {
+        token,
+        notification: { title: msg.title, body: msg.body },
+        ...(msg.data ? { data: stringifyData(msg.data) } : {}),
+      },
+    }),
+  }).catch((err) => { console.error('[push] FCM send fetch failed:', err); return null; });
+
+  if (!res) return { status: 0, reason: 'fetch_failed' };
+  return { status: res.status, reason: res.ok ? undefined : (await res.text()).slice(0, 200) };
+}

package/src/server/push/push.ts

@@ -0,0 +1,66 @@
+// PushModule — provider-agnostic send: resolve a user's tokens, route to APNs/FCM,
+// prune dead tokens. Gated OFF unless PUSH_ENABLED=true AND creds for at least one
+// provider are present (zero behavior change otherwise).
+import { sendApns, apnsConfigured, apnsTopic, isApnsTokenDead, type PushMessage } from './apns.ts';
+import { sendFcm, fcmConfigured, isFcmTokenDead } from './fcm.ts';
+import { listForUid, removeToken, touchToken } from './store.ts';
+
+const env = (k: string) => process.env[k] || '';
+
+/** Master gate: feature flag ON + at least one provider configured. */
+export function pushEnabled(): boolean {
+  if (env('PUSH_ENABLED') !== 'true') return false;
+  return apnsConfigured() || fcmConfigured();
+}
+
+export class PushModuleOptions {
+  /** Senders are injectable so triggers/tests can stub them; defaults hit the real providers. */
+  sendApns = sendApns;
+  sendFcm = sendFcm;
+}
+
+export class PushModule {
+  public options: PushModuleOptions;
+
+  public constructor(options?: Partial<PushModuleOptions>) {
+    this.options = { ...new PushModuleOptions(), ...options };
+  }
+
+  public enabled(): boolean {
+    return pushEnabled();
+  }
+
+  /** Send a notification to every device a user has registered; prune dead tokens. */
+  public async send(uid: string, msg: PushMessage): Promise<void> {
+    if (!this.enabled()) return;
+    const tokens = listForUid(uid);
+    if (!tokens.length) return;
+    for (const t of tokens) {
+      try {
+        if (t.platform === 'apns') {
+          const r = await this.options.sendApns(t.token, t.topic || apnsTopic(), msg);
+          if (r.status >= 200 && r.status < 300) {
+            touchToken(uid, t.token);
+          } else if (isApnsTokenDead(r.status, r.reason)) {
+            console.warn(`[push] pruning dead apns token for ${uid.slice(0, 8)} (${r.status} ${r.reason})`);
+            removeToken(uid, t.token);
+          } else {
+            console.warn(`[push] apns send failed for ${uid.slice(0, 8)}: ${r.status} ${r.reason}`);
+          }
+        } else {
+          const r = await this.options.sendFcm(t.token, msg);
+          if (r.status >= 200 && r.status < 300) {
+            touchToken(uid, t.token);
+          } else if (isFcmTokenDead(r.status, r.reason)) {
+            console.warn(`[push] pruning dead fcm token for ${uid.slice(0, 8)} (${r.status})`);
+            removeToken(uid, t.token);
+          } else {
+            console.warn(`[push] fcm send failed for ${uid.slice(0, 8)}: ${r.status} ${r.reason}`);
+          }
+        }
+      } catch (err) {
+        console.error(`[push] send error for ${uid.slice(0, 8)} (${t.platform}):`, err);
+      }
+    }
+  }
+}

package/src/server/push/store.ts

@@ -0,0 +1,84 @@
+// Flat-file device-token store for remote push — no DB (house rule).
+// `data/push-tokens.json`, keyed by uid → [{ token, platform, topic, addedAt, lastSeen }].
+// Re-registering the same token is an upsert (refreshes lastSeen / platform / topic).
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { dataPath } from '../paths.ts';
+
+export type PushPlatform = 'apns' | 'fcm';
+
+export interface PushToken {
+  token: string;
+  platform: PushPlatform;
+  topic?: string;
+  addedAt: number;
+  lastSeen: number;
+}
+
+type Store = Record<string, PushToken[]>;
+
+const FILE = dataPath('push-tokens.json');
+
+function load(): Store {
+  if (!existsSync(FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(FILE, 'utf-8')) as Store;
+  } catch (err) {
+    console.error('[push] token store read failed, starting empty:', err);
+    return {};
+  }
+}
+
+function save(store: Store): void {
+  mkdirSync(path.dirname(FILE), { recursive: true });
+  writeFileSync(FILE, JSON.stringify(store, null, 2));
+}
+
+/** Insert or refresh a token for a user. A token can only belong to one uid; if it
+ *  re-appears under a new uid (device handed over) it migrates to the latest owner. */
+export function upsertToken(uid: string, token: string, platform: PushPlatform, topic?: string): void {
+  const store = load();
+  // Drop this token from any other uid so it isn't double-delivered.
+  for (const [otherUid, list] of Object.entries(store)) {
+    if (otherUid === uid) continue;
+    const filtered = list.filter((t) => t.token !== token);
+    if (filtered.length !== list.length) store[otherUid] = filtered;
+  }
+  const list = store[uid] ?? [];
+  const now = Date.now();
+  const existing = list.find((t) => t.token === token);
+  if (existing) {
+    existing.platform = platform;
+    existing.topic = topic;
+    existing.lastSeen = now;
+  } else {
+    list.push({ token, platform, topic, addedAt: now, lastSeen: now });
+  }
+  store[uid] = list;
+  save(store);
+}
+
+/** Remove a token for a user (unregister, or pruning a dead token). */
+export function removeToken(uid: string, token: string): void {
+  const store = load();
+  const list = store[uid];
+  if (!list) return;
+  const filtered = list.filter((t) => t.token !== token);
+  if (filtered.length === list.length) return;
+  if (filtered.length) store[uid] = filtered;
+  else delete store[uid];
+  save(store);
+}
+
+/** Mark a token as recently delivered-to (housekeeping; cheap). */
+export function touchToken(uid: string, token: string): void {
+  const store = load();
+  const entry = store[uid]?.find((t) => t.token === token);
+  if (!entry) return;
+  entry.lastSeen = Date.now();
+  save(store);
+}
+
+export function listForUid(uid: string): PushToken[] {
+  return load()[uid] ?? [];
+}

package/src/server/push/triggers.ts

@@ -0,0 +1,99 @@
+// Push triggers — wire "everything notable" → PushModule.send, mirroring the
+// session-bus IoC pattern: index.ts calls initPushTriggers() at boot with the
+// deps it owns (origin, foreground-presence check), then calls the small
+// pushTurnDone/pushQuestion hooks from inside the request path. schedule.finished
+// is consumed off the event bus. No import of index.ts → no cycle.
+//
+// Light dedup + per-(uid,kind,session) rate-limit so notable events don't spam.
+import { PushModule } from './push.ts';
+import { subscribeEvents } from '../events/bus.ts';
+import { getSession } from '../sessions.ts';
+
+export type PushKind = 'turn-done' | 'question' | 'schedule';
+
+export interface PushTriggerDeps {
+  /** This server's public origin, embedded in `data.instance` for device onTap routing. */
+  origin: string;
+  /** True if the user has a foreground client actively viewing this session. */
+  isForeground: (uid: string, sessionId: string) => boolean;
+}
+
+const RATE_MS = 10_000;
+
+let push: PushModule | null = null;
+let deps: PushTriggerDeps | null = null;
+const lastSent = new Map<string, number>();
+
+export function initPushTriggers(d: PushTriggerDeps): void {
+  deps = d;
+  push = new PushModule();
+  subscribeEvents((evt) => {
+    if (evt.source === 'schedule.finished') onScheduleFinished(evt.payload);
+  });
+  console.log(`[push] triggers initialized (enabled=${push.enabled()}, origin=${d.origin || '<unset>'})`);
+}
+
+/** Dedup + rate-limit gate. Returns false if this (uid,kind,session) fired too recently. */
+function gate(uid: string, kind: PushKind, sessionId: string): boolean {
+  const key = `${uid}:${kind}:${sessionId}`;
+  const now = Date.now();
+  const last = lastSent.get(key);
+  if (last && now - last < RATE_MS) return false;
+  lastSent.set(key, now);
+  if (lastSent.size > 1000) {
+    for (const [k, ts] of lastSent) if (now - ts > RATE_MS * 6) lastSent.delete(k);
+  }
+  return true;
+}
+
+function data(sessionId: string, kind: PushKind): Record<string, unknown> {
+  return { instance: deps?.origin || '', session: sessionId, kind };
+}
+
+function titleFor(sessionId: string, fallback: string): string {
+  return getSession(sessionId)?.title?.trim() || fallback;
+}
+
+/** Turn finished (session_busy → false). Owner only; skip if they're looking at this session. */
+export function pushTurnDone(uid: string, sessionId: string): void {
+  if (!push?.enabled() || !deps) return;
+  if (deps.isForeground(uid, sessionId)) return;
+  if (!gate(uid, 'turn-done', sessionId)) return;
+  void push.send(uid, {
+    title: titleFor(sessionId, 'Shraga'),
+    body: 'The agent finished responding.',
+    data: data(sessionId, 'turn-done'),
+  });
+}
+
+/** Agent is asking the user a question (AskUserQuestion) — always notable. */
+export function pushQuestion(uid: string, sessionId: string): void {
+  if (!push?.enabled()) return;
+  if (!gate(uid, 'question', sessionId)) return;
+  void push.send(uid, {
+    title: titleFor(sessionId, 'Shraga'),
+    body: 'The agent needs your input.',
+    data: data(sessionId, 'question'),
+  });
+}
+
+function onScheduleFinished(payload: unknown): void {
+  if (!push?.enabled()) return;
+  const p = (payload || {}) as { scheduleId?: string; name?: string; status?: string; sessionId?: string; error?: string };
+  const sessionId = p.sessionId;
+  if (!sessionId) return;
+  const uid = getSession(sessionId)?.uid;
+  if (!uid) return;
+  if (!gate(uid, 'schedule', sessionId)) return;
+  const body =
+    p.status === 'ok'
+      ? 'Schedule completed.'
+      : p.status === 'aborted'
+        ? 'Schedule aborted.'
+        : `Schedule failed${p.error ? `: ${p.error.slice(0, 120)}` : '.'}`;
+  void push.send(uid, {
+    title: p.name || 'Scheduled task',
+    body,
+    data: data(sessionId, 'schedule'),
+  });
+}

package/src/server/scheduler/builtins.ts

@@ -0,0 +1,157 @@
+import type { Schedule } from './types.ts';
+
+export const SYSTEM_UID = '__system__';
+export const NIGHTLY_RECONCILE_SCHEDULE_ID = 'builtin-nightly-reconcile';
+export const DAILY_GARDEN_SCHEDULE_ID = 'builtin-daily-garden';
+export const HOURLY_SUMMARIZER_SCHEDULE_ID = 'builtin-conversation-summarizer';
+export const FAILURE_NOTIFIER_SCHEDULE_ID = 'builtin-failure-notifier';
+
+/** Generic triage prompt for the failure notifier. Deployments override the prompt
+ *  (recipients, runbooks, base URL, severity rules) — their edits survive reconcile. */
+const FAILURE_NOTIFIER_PROMPT = [
+  'A scheduled job just FAILED. The failure event payload is included in this message',
+  '(fields: name, scheduleId, status, error, sessionId). Duplicate alerts for the same',
+  'job+error are already suppressed by this trigger\'s throttle, so just handle this one.',
+  '',
+  'TRIAGE — classify the error:',
+  '  - Credential/auth expiry ("token expired", invalid_grant, 401/403, OAuthException): fix = regenerate/refresh the credential.',
+  '  - Rate limit (429, "rate limit", "request limit reached"): likely transient/self-healing.',
+  '  - Data issue (empty/missing results, 0 rows): check the upstream source.',
+  '  - Otherwise: generic failure; surface the raw error.',
+  'Severity is HIGH for revenue/reporting-critical jobs, otherwise NORMAL.',
+  '',
+  'NOTIFY — send exactly ONE concise alert to the deployment owner, then stop. Prefer a Slack DM',
+  'if a Slack tool is configured (resolve the owner from $SHRAGA_ALERT_SLACK_EMAIL (or legacy $UNCLAW_ALERT_SLACK_EMAIL), else the first',
+  'entry in data/whitelist.json); otherwise email them. Suggested format:',
+  '  :rotating_light: *<category>*<add " [HIGH]" if high severity> — scheduled job failed: *<name>*',
+  '  *What:* <one plain-language line>',
+  '  *Fix:* <actionable next step from triage>',
+  '  *Error:* <error, truncated to ~400 chars, in backticks>',
+  '  *Session:* <deployment URL>/?session=<sessionId>',
+  'Do NOT try to fix the job yourself.',
+].join('\n');
+
+export function isSystemSchedule(schedule: Schedule): boolean {
+  return schedule.scope === 'system';
+}
+
+/** Backfill `scope` and migrate legacy task.kind names on schedules persisted before the rename. */
+export function backfillScope(schedules: Schedule[]): void {
+  for (const s of schedules) {
+    if (!s.scope) {
+      s.scope = s.createdBy?.uid === SYSTEM_UID ? 'system' : 'user';
+    }
+    const kind = (s.task as { kind: string } | undefined)?.kind;
+    if (kind === 'agent') (s.task as { kind: string }).kind = 'prompt';
+    else if (kind === 'builtin') (s.task as { kind: string }).kind = 'job';
+
+    // Migrate legacy jobId-based tasks to command-based
+    const task = s.task as any;
+    if (task.kind === 'job' && task.jobId && !task.command) {
+      const legacyMap: Record<string, string> = {
+        'daily-facebook-ads-spend': 'bun run data/scripts/daily-fb-ads-spend.ts',
+        'daily-payback-sheet': 'bun run data/scripts/daily-payback-sheet.ts --slack',
+        'conversation-summarizer': 'bun run summarize:conversations',
+      };
+      task.command = legacyMap[task.jobId] ?? task.jobId;
+      delete task.jobId;
+    }
+  }
+}
+
+export function ensureBuiltinSchedules(schedules: Schedule[]): Schedule[] {
+  const now = Date.now();
+  const builtins: Schedule[] = [
+    defaultAgentSchedule({
+      id: DAILY_GARDEN_SCHEDULE_ID,
+      name: 'Daily Knowledge Garden',
+      expr: '0 13 * * *',
+      prompt: '/garden',
+      now,
+    }),
+    defaultAgentSchedule({
+      id: NIGHTLY_RECONCILE_SCHEDULE_ID,
+      name: 'Nightly Knowledge Reconciliation',
+      expr: '0 3 * * *',
+      prompt: '/reconcile',
+      now,
+    }),
+    {
+      id: HOURLY_SUMMARIZER_SCHEDULE_ID,
+      name: 'Conversation Summarizer',
+      enabled: false,
+      trigger: { kind: 'cron', expr: '0 * * * *', tz: 'UTC' },
+      task: { kind: 'job', command: 'bun run summarize:conversations' },
+      scope: 'system',
+      createdBy: { uid: SYSTEM_UID, email: 'system@shraga.local' },
+      createdAt: now,
+      updatedAt: now,
+      runCount: 0,
+    },
+    {
+      id: FAILURE_NOTIFIER_SCHEDULE_ID,
+      name: 'Scheduled-job failure notifier',
+      enabled: false,
+      // Fires on any failed schedule run; throttle dedups same job+error within 6h
+      // BEFORE spawning a run. (schedule.finished is suppressed for event-triggered
+      // runs, so the notifier can't trigger itself.)
+      trigger: {
+        kind: 'event',
+        source: 'schedule.finished',
+        match: { status: 'error' },
+        throttle: { byFields: ['name', 'error'], windowSec: 21600 },
+      },
+      task: { kind: 'prompt', prompt: FAILURE_NOTIFIER_PROMPT },
+      scope: 'system',
+      createdBy: { uid: SYSTEM_UID, email: 'system@shraga.local' },
+      createdAt: now,
+      updatedAt: now,
+      runCount: 0,
+    },
+  ];
+
+  const builtinIds = new Set(builtins.map((b) => b.id));
+
+  // Remove system schedules no longer in the builtins list (renamed/retired)
+  for (let i = schedules.length - 1; i >= 0; i--) {
+    if (schedules[i].scope === 'system' && schedules[i].createdBy?.uid === SYSTEM_UID && !builtinIds.has(schedules[i].id)) {
+      schedules.splice(i, 1);
+    }
+  }
+
+  for (const builtin of builtins) {
+    const existing = schedules.find((s) => s.id === builtin.id);
+    if (existing) {
+      existing.name = builtin.name;
+      existing.scope = builtin.scope;
+      existing.trigger = existing.trigger ?? builtin.trigger;
+      existing.createdBy = builtin.createdBy;
+    } else {
+      schedules.push(builtin);
+    }
+  }
+
+  return schedules;
+}
+
+function defaultAgentSchedule(options: {
+  id: string;
+  name: string;
+  expr: string;
+  prompt: string;
+  now: number;
+  scope?: 'system' | 'user';
+}): Schedule {
+  return {
+    id: options.id,
+    name: options.name,
+    enabled: false,
+    trigger: { kind: 'cron', expr: options.expr, tz: 'UTC' },
+    task: { kind: 'prompt', prompt: options.prompt },
+    scope: options.scope || 'system',
+    createdBy: { uid: SYSTEM_UID, email: 'system@shraga.local' },
+    createdAt: options.now,
+    updatedAt: options.now,
+    runCount: 0,
+  };
+}