airaknit 1.1.2-rc.9

package/src/server/push-notifications.test.ts

@@ -0,0 +1,234 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import {
+  PushSubscriptionStore,
+  createPushRouter,
+  initVapid,
+  getVapidPublicKey,
+  type StoredPushSubscription,
+} from "./push-notifications"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+
+describe("PushSubscriptionStore", () => {
+  let dir: string
+  let store: PushSubscriptionStore
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "push-test-"))
+    store = new PushSubscriptionStore(path.join(dir, "push-subscriptions.json"))
+  })
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  test("add and list subscriptions", () => {
+    const sub: StoredPushSubscription = {
+      endpoint: "https://push.example.com/abc",
+      keys: { p256dh: "key1", auth: "auth1" },
+    }
+    store.add(sub)
+    expect(store.getAll()).toHaveLength(1)
+    expect(store.getAll()[0].endpoint).toBe("https://push.example.com/abc")
+  })
+
+  test("deduplicates by endpoint", () => {
+    const sub: StoredPushSubscription = {
+      endpoint: "https://push.example.com/abc",
+      keys: { p256dh: "key1", auth: "auth1" },
+    }
+    store.add(sub)
+    store.add(sub)
+    expect(store.getAll()).toHaveLength(1)
+  })
+
+  test("remove by endpoint", () => {
+    const sub: StoredPushSubscription = {
+      endpoint: "https://push.example.com/abc",
+      keys: { p256dh: "key1", auth: "auth1" },
+    }
+    store.add(sub)
+    store.remove("https://push.example.com/abc")
+    expect(store.getAll()).toHaveLength(0)
+  })
+
+  test("persists to disk and loads back", async () => {
+    const sub: StoredPushSubscription = {
+      endpoint: "https://push.example.com/abc",
+      keys: { p256dh: "key1", auth: "auth1" },
+    }
+    store.add(sub)
+    await store.save()
+
+    const store2 = new PushSubscriptionStore(path.join(dir, "push-subscriptions.json"))
+    await store2.load()
+    expect(store2.getAll()).toHaveLength(1)
+    expect(store2.getAll()[0].endpoint).toBe("https://push.example.com/abc")
+  })
+
+  test("load handles missing file gracefully", async () => {
+    const store2 = new PushSubscriptionStore(path.join(dir, "nonexistent.json"))
+    await store2.load()
+    expect(store2.getAll()).toHaveLength(0)
+  })
+})
+
+describe("createPushRouter", () => {
+  let dir: string
+  let store: PushSubscriptionStore
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "push-test-"))
+    store = new PushSubscriptionStore(path.join(dir, "push-subscriptions.json"))
+  })
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  test("GET /api/push/vapid-key returns public key", async () => {
+    const savedPublic = process.env.VAPID_PUBLIC_KEY
+    const savedPrivate = process.env.VAPID_PRIVATE_KEY
+    // Use real VAPID keys (web-push validates key length)
+    const keys = (await import("web-push")).generateVAPIDKeys()
+    process.env.VAPID_PUBLIC_KEY = keys.publicKey
+    process.env.VAPID_PRIVATE_KEY = keys.privateKey
+
+    try {
+      initVapid()
+      const router = createPushRouter(store)
+      const req = new Request("http://localhost/api/push/vapid-key")
+      const res = await router(req)
+      expect(res.status).toBe(200)
+      const body = await res.json()
+      expect(body.publicKey).toBe(keys.publicKey)
+    } finally {
+      if (savedPublic) process.env.VAPID_PUBLIC_KEY = savedPublic
+      else delete process.env.VAPID_PUBLIC_KEY
+      if (savedPrivate) process.env.VAPID_PRIVATE_KEY = savedPrivate
+      else delete process.env.VAPID_PRIVATE_KEY
+    }
+  })
+
+  test("POST /api/push/subscribe adds subscription", async () => {
+    const router = createPushRouter(store)
+    const sub = {
+      endpoint: "https://push.example.com/xyz",
+      keys: { p256dh: "k", auth: "a" },
+    }
+    const req = new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(sub),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(201)
+    expect(store.getAll()).toHaveLength(1)
+  })
+
+  test("DELETE /api/push/subscribe removes subscription", async () => {
+    store.add({
+      endpoint: "https://push.example.com/xyz",
+      keys: { p256dh: "k", auth: "a" },
+    })
+    const router = createPushRouter(store)
+    const req = new Request("http://localhost/api/push/subscribe", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: "https://push.example.com/xyz" }),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    expect(store.getAll()).toHaveLength(0)
+  })
+
+  test("GET /api/push/vapid-key returns 503 when not configured", async () => {
+    const savedPublic = process.env.VAPID_PUBLIC_KEY
+    const savedPrivate = process.env.VAPID_PRIVATE_KEY
+    delete process.env.VAPID_PUBLIC_KEY
+    delete process.env.VAPID_PRIVATE_KEY
+
+    try {
+      initVapid()
+      const router = createPushRouter(store)
+      const req = new Request("http://localhost/api/push/vapid-key")
+      const res = await router(req)
+      expect(res.status).toBe(503)
+      const body = await res.json()
+      expect(body.error).toBe("Push notifications not configured")
+    } finally {
+      if (savedPublic) process.env.VAPID_PUBLIC_KEY = savedPublic
+      if (savedPrivate) process.env.VAPID_PRIVATE_KEY = savedPrivate
+    }
+  })
+
+  test("POST /api/push/subscribe validates body - missing fields returns 400", async () => {
+    const router = createPushRouter(store)
+
+    // Missing endpoint entirely
+    const res1 = await router(new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ keys: { p256dh: "k", auth: "a" } }),
+    }))
+    expect(res1.status).toBe(400)
+
+    // Missing keys
+    const res2 = await router(new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: "https://push.example.com/abc" }),
+    }))
+    expect(res2.status).toBe(400)
+
+    // Invalid JSON
+    const res3 = await router(new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "not json",
+    }))
+    expect(res3.status).toBe(400)
+
+    // Invalid endpoint URL
+    const res4 = await router(new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: "not-a-url", keys: { p256dh: "k", auth: "a" } }),
+    }))
+    expect(res4.status).toBe(400)
+
+    // Missing key fields (p256dh/auth)
+    const res5 = await router(new Request("http://localhost/api/push/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: "https://push.example.com/abc", keys: { p256dh: 123, auth: "a" } }),
+    }))
+    expect(res5.status).toBe(400)
+  })
+
+  test("unknown route returns 404", async () => {
+    const router = createPushRouter(store)
+    const req = new Request("http://localhost/api/push/unknown")
+    const res = await router(req)
+    expect(res.status).toBe(404)
+  })
+})
+
+describe("initVapid", () => {
+  test("returns false when env vars not set", () => {
+    const savedPublic = process.env.VAPID_PUBLIC_KEY
+    const savedPrivate = process.env.VAPID_PRIVATE_KEY
+    delete process.env.VAPID_PUBLIC_KEY
+    delete process.env.VAPID_PRIVATE_KEY
+
+    try {
+      const result = initVapid()
+      expect(result).toBe(false)
+      expect(getVapidPublicKey()).toBeNull()
+    } finally {
+      if (savedPublic) process.env.VAPID_PUBLIC_KEY = savedPublic
+      if (savedPrivate) process.env.VAPID_PRIVATE_KEY = savedPrivate
+    }
+  })
+})

package/src/server/push-notifications.ts

@@ -0,0 +1,188 @@
+import webpush from "web-push"
+import { LOG_PREFIX } from "../shared/branding"
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export interface StoredPushSubscription {
+  endpoint: string
+  keys: { p256dh: string; auth: string }
+}
+
+export interface PushPayload {
+  title: string
+  body: string
+  url?: string
+  tag?: string
+}
+
+// ── VAPID ──────────────────────────────────────────────────────────
+
+let vapidConfigured = false
+let vapidPublicKey: string | null = null
+
+export function initVapid(): boolean {
+  const publicKey = process.env.VAPID_PUBLIC_KEY
+  const privateKey = process.env.VAPID_PRIVATE_KEY
+  const subject = process.env.VAPID_SUBJECT ?? "mailto:tinkaria@localhost"
+
+  if (!publicKey || !privateKey) {
+    console.warn(LOG_PREFIX, "VAPID keys not configured — push notifications disabled")
+    vapidConfigured = false
+    vapidPublicKey = null
+    return false
+  }
+
+  webpush.setVapidDetails(subject, publicKey, privateKey)
+  vapidConfigured = true
+  vapidPublicKey = publicKey
+  console.warn(LOG_PREFIX, "Push notifications enabled (VAPID configured)")
+  return true
+}
+
+export function getVapidPublicKey(): string | null {
+  return vapidPublicKey
+}
+
+// ── Subscription Store ─────────────────────────────────────────────
+
+export class PushSubscriptionStore {
+  private subscriptions = new Map<string, StoredPushSubscription>()
+  private readonly filePath: string
+
+  constructor(filePath: string) {
+    this.filePath = filePath
+  }
+
+  add(sub: StoredPushSubscription): void {
+    this.subscriptions.set(sub.endpoint, sub)
+  }
+
+  remove(endpoint: string): void {
+    this.subscriptions.delete(endpoint)
+  }
+
+  getAll(): StoredPushSubscription[] {
+    return [...this.subscriptions.values()]
+  }
+
+  async save(): Promise<void> {
+    const data = JSON.stringify(this.getAll(), null, 2)
+    await Bun.write(this.filePath, data)
+  }
+
+  async load(): Promise<void> {
+    try {
+      const file = Bun.file(this.filePath)
+      if (!(await file.exists())) return
+      const data = await file.json()
+      if (!Array.isArray(data)) return
+      for (const sub of data) {
+        if (sub.endpoint && sub.keys?.p256dh && sub.keys?.auth) {
+          this.subscriptions.set(sub.endpoint, sub)
+        }
+      }
+    } catch (err: unknown) {
+      console.warn(LOG_PREFIX, "Failed to load push subscriptions:", err instanceof Error ? err.message : String(err))
+    }
+  }
+}
+
+// ── Push Sender ────────────────────────────────────────────────────
+
+export async function sendPushToAll(
+  store: PushSubscriptionStore,
+  payload: PushPayload,
+): Promise<void> {
+  if (!vapidConfigured) return
+
+  const subscriptions = store.getAll()
+  if (subscriptions.length === 0) return
+
+  const body = JSON.stringify(payload)
+  const expiredEndpoints: string[] = []
+
+  await Promise.allSettled(
+    subscriptions.map(async (sub) => {
+      try {
+        await webpush.sendNotification(
+          { endpoint: sub.endpoint, keys: sub.keys },
+          body,
+        )
+      } catch (err: unknown) {
+        const statusCode = err instanceof Error && "statusCode" in err
+          ? (err as { statusCode: number }).statusCode
+          : 0
+        if (statusCode === 404 || statusCode === 410) {
+          expiredEndpoints.push(sub.endpoint)
+        } else {
+          console.warn(
+            LOG_PREFIX,
+            `Push failed for ${sub.endpoint}:`,
+            err instanceof Error ? err.message : String(err),
+          )
+        }
+      }
+    }),
+  )
+
+  // Clean up expired subscriptions
+  for (const endpoint of expiredEndpoints) {
+    store.remove(endpoint)
+  }
+  if (expiredEndpoints.length > 0) {
+    await store.save()
+  }
+}
+
+// ── HTTP Router ────────────────────────────────────────────────────
+
+export function createPushRouter(
+  store: PushSubscriptionStore,
+): (req: Request) => Promise<Response> {
+  return async (req: Request): Promise<Response> => {
+    const url = new URL(req.url)
+
+    if (url.pathname === "/api/push/vapid-key" && req.method === "GET") {
+      const key = getVapidPublicKey()
+      if (!key) {
+        return Response.json({ error: "Push notifications not configured" }, { status: 503 })
+      }
+      return Response.json({ publicKey: key })
+    }
+
+    if (url.pathname === "/api/push/subscribe" && req.method === "POST") {
+      let body: Record<string, unknown>
+      try { body = await req.json() } catch {
+        return Response.json({ error: "Invalid JSON" }, { status: 400 })
+      }
+      if (!body.endpoint || typeof body.endpoint !== "string" || !body.keys) {
+        return Response.json({ error: "Invalid subscription" }, { status: 400 })
+      }
+      try { new URL(body.endpoint) } catch {
+        return Response.json({ error: "Invalid endpoint URL" }, { status: 400 })
+      }
+      const keys = body.keys as Record<string, unknown>
+      if (typeof keys.p256dh !== "string" || typeof keys.auth !== "string") {
+        return Response.json({ error: "Invalid subscription keys" }, { status: 400 })
+      }
+      store.add({ endpoint: body.endpoint, keys: { p256dh: keys.p256dh, auth: keys.auth } })
+      await store.save()
+      return Response.json({ ok: true }, { status: 201 })
+    }
+
+    if (url.pathname === "/api/push/subscribe" && req.method === "DELETE") {
+      let body: Record<string, unknown>
+      try { body = await req.json() } catch {
+        return Response.json({ error: "Invalid JSON" }, { status: 400 })
+      }
+      if (!body.endpoint || typeof body.endpoint !== "string") {
+        return Response.json({ error: "Missing endpoint" }, { status: 400 })
+      }
+      store.remove(body.endpoint)
+      await store.save()
+      return Response.json({ ok: true })
+    }
+
+    return Response.json({ error: "Not found" }, { status: 404 })
+  }
+}

package/src/server/quick-response.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, test } from "bun:test"
+import { generateTitleForChat } from "./generate-title"
+import { generateForkPromptForChat } from "./generate-fork-context"
+import { QuickResponseAdapter } from "./quick-response"
+
+describe("QuickResponseAdapter", () => {
+  test("returns the Claude structured result when it validates", async () => {
+    const adapter = new QuickResponseAdapter({
+      runClaudeStructured: async () => ({ title: "Claude title" }),
+      runCodexStructured: async () => ({ title: "Codex title" }),
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Claude title")
+  })
+
+  test("falls back to Codex when Claude fails validation", async () => {
+    const adapter = new QuickResponseAdapter({
+      runClaudeStructured: async () => ({ bad: true }),
+      runCodexStructured: async () => ({ title: "Codex title" }),
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Codex title")
+  })
+
+  test("falls back to Codex when Claude throws", async () => {
+    const adapter = new QuickResponseAdapter({
+      runClaudeStructured: async () => {
+        throw new Error("Not authenticated")
+      },
+      runCodexStructured: async () => ({ title: "Codex title" }),
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Codex title")
+  })
+})
+
+describe("generateTitleForChat", () => {
+  test("sanitizes generated titles", async () => {
+    const title = await generateTitleForChat(
+      "hello",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => ({ title: "   Example\nTitle   " }),
+      })
+    )
+
+    expect(title).toBe("Example Title")
+  })
+
+  test("rejects invalid generated titles", async () => {
+    const title = await generateTitleForChat(
+      "hello",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => ({ title: "   " }),
+        runCodexStructured: async () => ({ title: "New Chat" }),
+      })
+    )
+
+    expect(title).toBeNull()
+  })
+})
+
+describe("generateForkPromptForChat", () => {
+  test("builds a dedicated-session brief from analyzed intent and compacted context", async () => {
+    const prompt = await generateForkPromptForChat(
+      "Focus on the auth race fix",
+      [],
+      "/tmp/project",
+      undefined,
+      new QuickResponseAdapter({
+        runClaudeStructured: async (args) => {
+          if (args.task.includes("analysis")) {
+            return {
+              compactInstruction: "Keep the auth-race evidence only.",
+              nextInstruction: "Fix the auth race.",
+            }
+          }
+          return {
+            summary: "## Relevant Context\nKeep the existing API.",
+          }
+        },
+      }),
+    )
+
+    expect(prompt).toBe([
+      "## Objective",
+      "Fix the auth race.",
+      "",
+      "## Relevant Context",
+      "## Relevant Context",
+      "Keep the existing API.",
+      "",
+      "## Constraints",
+      "Preserve proven constraints from the context above. Call out contradictions or missing evidence before making risky changes.",
+      "",
+      "## Next Step",
+      "Start directly on the objective using the compacted context above.",
+    ].join("\n"))
+  })
+
+  test("falls back to a composed brief when structured output is invalid", async () => {
+    const prompt = await generateForkPromptForChat(
+      "   Continue the mobile keyboard fix   ",
+      [],
+      "/tmp/project",
+      undefined,
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => ({ nope: true }),
+        runCodexStructured: async () => ({ prompt: "   " }),
+      }),
+    )
+
+    expect(prompt).toContain("## Objective\nContinue the mobile keyboard fix")
+    expect(prompt).toContain("## Relevant Context\nNo prior transcript context was available.")
+  })
+
+  test("includes preset guidance in the analysis prompt", async () => {
+    let capturedPrompt = ""
+    await generateForkPromptForChat(
+      "Focus on an alternative design",
+      [],
+      "/tmp/project",
+      "alternative_approach",
+      new QuickResponseAdapter({
+        runClaudeStructured: async (args) => {
+          if (args.task.includes("analysis")) {
+            capturedPrompt = args.prompt
+            return {
+              compactInstruction: "Preserve only the key constraints.",
+              nextInstruction: "Explore the alternative.",
+            }
+          }
+          return { summary: "## Relevant Context\nAlternative-ready constraints." }
+        },
+      }),
+    )
+
+    expect(capturedPrompt).toContain("Selected preset: Alternative approach.")
+    expect(capturedPrompt).toContain("exploring a different solution path")
+  })
+})