@cuongtran001/kanna 0.39.2

package/src/server/auto-continue/e2e.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { AgentCoordinator } from "../agent"
+import { EventStore } from "../event-store"
+import { AsyncEventQueue } from "../test-helpers/async-event-queue"
+import { waitFor } from "../test-helpers/wait-for"
+import type { AutoContinueEvent } from "./events"
+import { ClaudeLimitDetector, CodexLimitDetector } from "./limit-detector"
+import { ScheduleManager, type Clock } from "./schedule-manager"
+
+// ---------------------------------------------------------------------------
+// FakeClock — controllable wall-clock for ScheduleManager
+// ---------------------------------------------------------------------------
+
+class FakeClock implements Clock {
+  private currentTime: number
+  private readonly timers = new Map<number, { fn: () => void; fireAt: number }>()
+  private nextId = 1
+
+  constructor(startAt: number) {
+    this.currentTime = startAt
+  }
+
+  now(): number {
+    return this.currentTime
+  }
+
+  setTimeout(fn: () => void, delayMs: number): number {
+    const id = this.nextId++
+    this.timers.set(id, { fn, fireAt: this.currentTime + delayMs })
+    return id
+  }
+
+  clearTimeout(id: number): void {
+    this.timers.delete(id)
+  }
+
+  advance(ms: number): void {
+    this.currentTime += ms
+    for (const [id, timer] of [...this.timers.entries()]) {
+      if (timer.fireAt <= this.currentTime) {
+        this.timers.delete(id)
+        timer.fn()
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Build a rate-limit error that ClaudeLimitDetector recognises.
+ *
+ *  The `anthropic-ratelimit-unified-reset` header is set to
+ *  `new Date(resetAt).toISOString()` so the detector returns exactly
+ *  `resetAt` as the reset timestamp.
+ */
+function makeRateLimitError(resetAt: number): Error & { status: number; headers: Record<string, string> } {
+  const err = new Error(
+    JSON.stringify({ type: "error", error: { type: "rate_limit_error" } })
+  ) as Error & { status: number; headers: Record<string, string> }
+  err.status = 429
+  err.headers = {
+    "anthropic-ratelimit-unified-reset": new Date(resetAt).toISOString(),
+    "x-anthropic-timezone": "Asia/Saigon",
+  }
+  return err
+}
+
+// ---------------------------------------------------------------------------
+// End-to-end test
+// ---------------------------------------------------------------------------
+
+describe("auto-continue end-to-end", () => {
+  test("rate limit → proposed → accept → timer fires → auto_continue_fired + 'continue' user_prompt", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "kanna-ac-e2e-"))
+    let scheduleManager: ScheduleManager | undefined
+    try {
+      // --- Set up real EventStore ---
+      const store = new EventStore(dir)
+      await store.initialize()
+      const project = await store.openProject("/tmp/e2e-proj")
+      const chat = await store.createChat(project.id)
+      const chatId = chat.id
+
+      // --- FakeClock anchored to real wall-clock so scheduledAt guard passes ---
+      // acceptAutoContinue checks `scheduledAt > Date.now()` using real Date.now().
+      // ScheduleManager.arm computes `delay = scheduledAt - clock.now()`.
+      // By starting the fake clock at Date.now(), both quantities agree and
+      // a 10s delta is large enough to survive slow CI runners.
+      const clockStart = Date.now()
+      const clock = new FakeClock(clockStart)
+      const resetAtMs = clockStart + 10_000 // rate-limit resets 10s "from now"
+
+      // --- ScheduleManager + coordinator (forward-reference pattern) ---
+      let coordinator!: AgentCoordinator
+      scheduleManager = new ScheduleManager({
+        clock,
+        fire: async (cid, sid) => {
+          await coordinator.fireAutoContinue(cid, sid)
+        },
+      })
+
+      // Async event queue so we can throw a rate-limit error on demand.
+      const events = new AsyncEventQueue<never>()
+
+      coordinator = new AgentCoordinator({
+        store,
+        onStateChange: () => {},
+        claudeLimitDetector: new ClaudeLimitDetector(),
+        codexLimitDetector: new CodexLimitDetector(),
+        scheduleManager,
+        // manual mode: do NOT auto-resume so we exercise the proposed → accept path
+        getAutoResumePreference: () => false,
+        startClaudeSession: async () => ({
+          provider: "claude" as const,
+          stream: events,
+          getAccountInfo: async () => null,
+          interrupt: async () => {},
+          close: () => {},
+          setModel: async () => {},
+          setPermissionMode: async () => {},
+          getSupportedCommands: async () => [],
+          sendPrompt: async () => {
+            // Throw a rate-limit error; this is caught by runClaudeSession
+            // which routes it through handleLimitError → ClaudeLimitDetector.
+            events.throw(makeRateLimitError(resetAtMs))
+          },
+        }),
+      })
+
+      // ----------------------------------------------------------------
+      // Step 1: Send a message; session throws a rate-limit error.
+      // ----------------------------------------------------------------
+      await coordinator.send({
+        type: "chat.send",
+        chatId,
+        content: "hello",
+        model: "claude-opus-4-5",
+        provider: "claude",
+        autoResumeOnRateLimit: false,
+      })
+
+      // Wait for the proposed event to be persisted.
+      await waitFor(() => store.getAutoContinueEvents(chatId).length >= 1)
+
+      const acEventsAfterPropose = store.getAutoContinueEvents(chatId)
+      expect(acEventsAfterPropose).toHaveLength(1)
+      expect(acEventsAfterPropose[0].kind).toBe("auto_continue_proposed")
+      const proposed = acEventsAfterPropose[0] as Extract<AutoContinueEvent, { kind: "auto_continue_proposed" }>
+      expect(proposed.tz).toBe("Asia/Saigon")
+      const { scheduleId } = proposed
+
+      // ----------------------------------------------------------------
+      // Step 2: Client accepts — scheduleManager arms the timer.
+      // ----------------------------------------------------------------
+      const scheduledAt = clock.now() + 10_000 // in the future per both real and fake clock
+      await coordinator.acceptAutoContinue(chatId, scheduleId, scheduledAt)
+
+      const acEventsAfterAccept = store.getAutoContinueEvents(chatId)
+      expect(acEventsAfterAccept).toHaveLength(2)
+      const accepted = acEventsAfterAccept[1] as Extract<AutoContinueEvent, { kind: "auto_continue_accepted" }>
+      expect(accepted.kind).toBe("auto_continue_accepted")
+      expect(accepted.scheduleId).toBe(scheduleId)
+      expect(accepted.source).toBe("user")
+      expect(accepted.scheduledAt).toBe(scheduledAt)
+
+      // ----------------------------------------------------------------
+      // Step 3: Advance the fake clock past scheduledAt — timer fires.
+      // The ScheduleManager callback calls coordinator.fireAutoContinue
+      // which is async; we need to drain the microtask queue after advance.
+      // ----------------------------------------------------------------
+      clock.advance(10_100)
+
+      // ----------------------------------------------------------------
+      // Step 4: Assert auto_continue_fired event.
+      // ----------------------------------------------------------------
+      await waitFor(() =>
+        store.getAutoContinueEvents(chatId).some((e) => e.kind === "auto_continue_fired")
+      )
+
+      const acEventsAfterFire = store.getAutoContinueEvents(chatId)
+      const firedEvent = acEventsAfterFire.find(
+        (e) => e.kind === "auto_continue_fired"
+      ) as Extract<AutoContinueEvent, { kind: "auto_continue_fired" }> | undefined
+      expect(firedEvent).toBeDefined()
+      expect(firedEvent!.scheduleId).toBe(scheduleId)
+
+      // ----------------------------------------------------------------
+      // Step 5: Assert "continue" user_prompt with autoContinue metadata.
+      // ----------------------------------------------------------------
+      await waitFor(() =>
+        store.getMessages(chatId).some((m) => m.kind === "user_prompt" && m.content === "continue")
+      )
+
+      const messages = store.getMessages(chatId)
+      const continuePrompts = messages.filter(
+        (m) => m.kind === "user_prompt" && m.content === "continue"
+      )
+      expect(continuePrompts).toHaveLength(1)
+      const continuePrompt = continuePrompts[0]
+      if (continuePrompt?.kind === "user_prompt") {
+        expect(continuePrompt.autoContinue?.scheduleId).toBe(scheduleId)
+      } else {
+        throw new Error("Expected user_prompt entry")
+      }
+    } finally {
+      scheduleManager?.shutdown()
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+})

package/src/server/auto-continue/events.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test"
+import type { AutoContinueEvent } from "./events"
+
+describe("AutoContinueEvent", () => {
+  test("covers the five lifecycle kinds", () => {
+    const kinds: AutoContinueEvent["kind"][] = [
+      "auto_continue_proposed",
+      "auto_continue_accepted",
+      "auto_continue_rescheduled",
+      "auto_continue_cancelled",
+      "auto_continue_fired",
+    ]
+    expect(kinds.length).toBe(5)
+  })
+
+  test("proposed event carries reset + tz metadata", () => {
+    const event: AutoContinueEvent = {
+      v: 3,
+      kind: "auto_continue_proposed",
+      timestamp: 1_000,
+      chatId: "c1",
+      scheduleId: "s1",
+      detectedAt: 1_000,
+      resetAt: 2_000,
+      tz: "Asia/Saigon",
+
+    }
+    expect(event.tz).toBe("Asia/Saigon")
+  })
+})

package/src/server/auto-continue/events.ts

@@ -0,0 +1,35 @@
+export const AUTO_CONTINUE_EVENT_VERSION = 3 as const
+
+interface AutoContinueEventBase {
+  v: typeof AUTO_CONTINUE_EVENT_VERSION
+  timestamp: number
+  chatId: string
+  scheduleId: string
+}
+
+export type AutoContinueEvent =
+  | (AutoContinueEventBase & {
+      kind: "auto_continue_proposed"
+      detectedAt: number
+      resetAt: number
+      tz: string
+    })
+  | (AutoContinueEventBase & {
+      kind: "auto_continue_accepted"
+      scheduledAt: number
+      tz: string
+      source: "user" | "auto_setting"
+      resetAt: number
+      detectedAt: number
+    })
+  | (AutoContinueEventBase & {
+      kind: "auto_continue_rescheduled"
+      scheduledAt: number
+    })
+  | (AutoContinueEventBase & {
+      kind: "auto_continue_cancelled"
+      reason: "user" | "chat_deleted"
+    })
+  | (AutoContinueEventBase & {
+      kind: "auto_continue_fired"
+    })

package/src/server/auto-continue/limit-detector.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test"
+import { ClaudeLimitDetector, CodexLimitDetector, parseResetFromText } from "./limit-detector"
+
+const detector = new ClaudeLimitDetector()
+
+function anthropicError(body: Record<string, unknown>, headers: Record<string, string> = {}) {
+  const error = new Error(JSON.stringify(body)) as Error & { status?: number; headers?: Record<string, string> }
+  error.status = 429
+  error.headers = headers
+  return error
+}
+
+describe("ClaudeLimitDetector", () => {
+  test("returns null for non-rate-limit errors", () => {
+    const err = new Error("Something unrelated went wrong")
+    expect(detector.detect("c1", err)).toBeNull()
+  })
+
+  test("detects rate limit with ISO reset timestamp in headers", () => {
+    const resetIso = "2026-04-23T00:00:00+07:00"
+    const err = anthropicError(
+      { type: "error", error: { type: "rate_limit_error", message: "You've hit your limit · resets 12am (Asia/Saigon)" } },
+      { "anthropic-ratelimit-unified-reset": resetIso, "x-anthropic-timezone": "Asia/Saigon" }
+    )
+    const detection = detector.detect("c1", err)
+    expect(detection).not.toBeNull()
+    expect(detection!.chatId).toBe("c1")
+    expect(detection!.resetAt).toBe(new Date(resetIso).getTime())
+    expect(detection!.tz).toBe("Asia/Saigon")
+  })
+
+  test("falls back to tz=system when no timezone header is present", () => {
+    const resetIso = "2026-04-23T05:00:00Z"
+    const err = anthropicError(
+      { type: "error", error: { type: "rate_limit_error" } },
+      { "anthropic-ratelimit-unified-reset": resetIso }
+    )
+    const detection = detector.detect("c1", err)
+    expect(detection!.tz).toBe("system")
+  })
+
+  test("returns null when the payload is rate-limit but no reset timestamp can be parsed", () => {
+    const err = anthropicError({ type: "error", error: { type: "rate_limit_error" } })
+    expect(detector.detect("c1", err)).toBeNull()
+  })
+
+  test("parses resetAt from the message body when headers are absent", () => {
+    const resetIso = "2026-04-23T00:00:00+07:00"
+    const err = new Error(JSON.stringify({
+      type: "error",
+      error: {
+        type: "rate_limit_error",
+        resets_at: resetIso,
+        timezone: "Asia/Saigon",
+      },
+    }))
+    const detection = detector.detect("c1", err)
+    expect(detection!.resetAt).toBe(new Date(resetIso).getTime())
+    expect(detection!.tz).toBe("Asia/Saigon")
+  })
+
+  test("does not match on status-only errors (400, 500, etc.)", () => {
+    const err = anthropicError({ type: "error", error: { type: "overloaded_error" } })
+    expect(detector.detect("c1", err)).toBeNull()
+  })
+})
+
+const codex = new CodexLimitDetector()
+
+describe("CodexLimitDetector", () => {
+  test("returns null for non-rate-limit JSON-RPC errors", () => {
+    const err = { code: -32601, message: "Method not found" }
+    expect(codex.detect("c1", err)).toBeNull()
+  })
+
+  test("detects rate limit from error.data.code with epoch-ms reset", () => {
+    const err = {
+      code: -32001,
+      message: "Rate limited",
+      data: { code: "rate_limit", resets_at_ms: 2_000_000, timezone: "Asia/Saigon" },
+    }
+    const detection = codex.detect("c1", err)
+    expect(detection!.resetAt).toBe(2_000_000)
+    expect(detection!.tz).toBe("Asia/Saigon")
+  })
+
+  test("detects rate limit with ISO resets_at", () => {
+    const resetIso = "2026-04-23T00:00:00+07:00"
+    const err = {
+      code: -32001,
+      message: "Rate limited",
+      data: { code: "rate_limit", resets_at: resetIso },
+    }
+    const detection = codex.detect("c1", err)
+    expect(detection!.resetAt).toBe(new Date(resetIso).getTime())
+    expect(detection!.tz).toBe("system")
+  })
+
+  test("returns null when no reset timestamp can be parsed", () => {
+    const err = { code: -32001, data: { code: "rate_limit" } }
+    expect(codex.detect("c1", err)).toBeNull()
+  })
+})
+
+describe("parseResetFromText", () => {
+  test("parses 'resets 2pm (Asia/Saigon)' for later-same-day", () => {
+    const now = Date.parse("2026-04-23T05:00:00Z") // 12:00 Saigon
+    const parsed = parseResetFromText("You've hit your limit · resets 2pm (Asia/Saigon)", now)
+    expect(parsed).not.toBeNull()
+    expect(parsed!.tz).toBe("Asia/Saigon")
+    expect(new Date(parsed!.resetAt).toISOString()).toBe("2026-04-23T07:00:00.000Z")
+  })
+
+  test("parses 'resets 2pm (Asia/Saigon)' wraps to next day if past", () => {
+    const now = Date.parse("2026-04-23T08:00:00Z") // 15:00 Saigon
+    const parsed = parseResetFromText("You've hit your limit · resets 2pm (Asia/Saigon)", now)
+    expect(new Date(parsed!.resetAt).toISOString()).toBe("2026-04-24T07:00:00.000Z")
+  })
+
+  test("parses '12am' as midnight", () => {
+    const now = Date.parse("2026-04-23T10:00:00Z")
+    const parsed = parseResetFromText("resets 12am (UTC)", now)
+    expect(new Date(parsed!.resetAt).toISOString()).toBe("2026-04-24T00:00:00.000Z")
+  })
+
+  test("returns null when no 'resets' token", () => {
+    expect(parseResetFromText("nothing interesting", Date.now())).toBeNull()
+  })
+
+  test("parses 'resets 2:40pm (Asia/Saigon)' with minutes", () => {
+    const now = Date.parse("2026-04-23T05:00:00Z") // 12:00 Saigon
+    const parsed = parseResetFromText("You've hit your limit · resets 2:40pm (Asia/Saigon)", now)
+    expect(parsed).not.toBeNull()
+    expect(parsed!.tz).toBe("Asia/Saigon")
+    expect(new Date(parsed!.resetAt).toISOString()).toBe("2026-04-23T07:40:00.000Z")
+  })
+
+  test("parses 'resets 12:30am (UTC)' with minutes wraps next day", () => {
+    const now = Date.parse("2026-04-23T10:00:00Z")
+    const parsed = parseResetFromText("resets 12:30am (UTC)", now)
+    expect(new Date(parsed!.resetAt).toISOString()).toBe("2026-04-24T00:30:00.000Z")
+  })
+})
+
+describe("ClaudeLimitDetector.detectFromResultText", () => {
+  test("detects from stream result text", () => {
+    const now = Date.parse("2026-04-23T05:00:00Z")
+    const detection = detector.detectFromResultText("c1", "You've hit your limit · resets 2pm (Asia/Saigon)", now)
+    expect(detection).not.toBeNull()
+    expect(detection!.tz).toBe("Asia/Saigon")
+    expect(new Date(detection!.resetAt).toISOString()).toBe("2026-04-23T07:00:00.000Z")
+  })
+})

package/src/server/auto-continue/limit-detector.ts

@@ -0,0 +1,159 @@
+export interface LimitDetection {
+  chatId: string
+  resetAt: number
+  tz: string
+  raw: unknown
+}
+
+export interface LimitDetector {
+  detect(chatId: string, error: unknown): LimitDetection | null
+  detectFromResultText?(chatId: string, text: string, nowMs?: number): LimitDetection | null
+}
+
+interface ErrorLike {
+  message?: string
+  status?: number
+  headers?: Record<string, string>
+}
+
+function extractHeaders(error: unknown): Record<string, string> {
+  if (error && typeof error === "object" && "headers" in error) {
+    const headers = (error as ErrorLike).headers
+    if (headers && typeof headers === "object") return headers
+  }
+  return {}
+}
+
+function parseBody(error: unknown): Record<string, unknown> | null {
+  if (!error || typeof error !== "object") return null
+  const message = (error as ErrorLike).message
+  if (!message) return null
+  try {
+    const parsed = JSON.parse(message)
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
+
+function parseIsoMillis(value: unknown): number | null {
+  if (typeof value !== "string" || !value) return null
+  const millis = new Date(value).getTime()
+  return Number.isFinite(millis) ? millis : null
+}
+
+function zonedWallClockToUtcMs(
+  year: number, month: number, day: number, hour: number, minute: number, tz: string,
+): number {
+  const utcGuess = Date.UTC(year, month - 1, day, hour, minute)
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit",
+    hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false,
+  })
+  const parts = Object.fromEntries(
+    dtf.formatToParts(new Date(utcGuess))
+      .filter((part) => part.type !== "literal")
+      .map((part) => [part.type, part.value]),
+  )
+  const asLocal = Date.UTC(
+    Number(parts.year), Number(parts.month) - 1, Number(parts.day),
+    parts.hour === "24" ? 0 : Number(parts.hour), Number(parts.minute),
+  )
+  return utcGuess - (asLocal - utcGuess)
+}
+
+export function parseResetFromText(text: string, nowMs: number = Date.now()): { resetAt: number; tz: string } | null {
+  if (typeof text !== "string") return null
+  const match = text.match(/resets\s+(\d{1,2})(?::(\d{2}))?(am|pm)\s*\(([^)]+)\)/i)
+  if (!match) return null
+  const hour12 = Number(match[1])
+  const minute = match[2] ? Number(match[2]) : 0
+  const meridiem = match[3].toLowerCase()
+  const tz = match[4].trim()
+  if (!Number.isFinite(hour12) || hour12 < 1 || hour12 > 12) return null
+  if (!Number.isFinite(minute) || minute < 0 || minute > 59) return null
+  const hour24 = meridiem === "pm"
+    ? (hour12 === 12 ? 12 : hour12 + 12)
+    : (hour12 === 12 ? 0 : hour12)
+  let tzYear: number, tzMonth: number, tzDay: number
+  try {
+    const dtf = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit",
+    })
+    const parts = Object.fromEntries(
+      dtf.formatToParts(new Date(nowMs))
+        .filter((part) => part.type !== "literal")
+        .map((part) => [part.type, part.value]),
+    )
+    tzYear = Number(parts.year)
+    tzMonth = Number(parts.month)
+    tzDay = Number(parts.day)
+  } catch {
+    return null
+  }
+  let resetAt = zonedWallClockToUtcMs(tzYear, tzMonth, tzDay, hour24, minute, tz)
+  if (resetAt <= nowMs) {
+    const next = new Date(Date.UTC(tzYear, tzMonth - 1, tzDay) + 24 * 3600_000)
+    resetAt = zonedWallClockToUtcMs(
+      next.getUTCFullYear(), next.getUTCMonth() + 1, next.getUTCDate(), hour24, minute, tz,
+    )
+  }
+  return { resetAt, tz }
+}
+
+export class ClaudeLimitDetector implements LimitDetector {
+  detect(chatId: string, error: unknown): LimitDetection | null {
+    const body = parseBody(error)
+    const inner = body && typeof body.error === "object" && body.error !== null
+      ? (body.error as Record<string, unknown>)
+      : null
+    const isRateLimit = inner?.type === "rate_limit_error"
+      || (error as ErrorLike | null)?.status === 429 && inner?.type === "rate_limit_error"
+    if (!isRateLimit) return null
+
+    const headers = extractHeaders(error)
+    const resetAt = parseIsoMillis(headers["anthropic-ratelimit-unified-reset"])
+      ?? parseIsoMillis(inner?.resets_at)
+      ?? parseIsoMillis(inner?.reset_at)
+    if (resetAt === null) return null
+
+    const tz = headers["x-anthropic-timezone"]
+      ?? (typeof inner?.timezone === "string" ? (inner.timezone as string) : null)
+      ?? "system"
+
+    return { chatId, resetAt, tz, raw: error }
+  }
+
+  detectFromResultText(chatId: string, text: string, nowMs: number = Date.now()): LimitDetection | null {
+    const parsed = parseResetFromText(text, nowMs)
+    if (!parsed) return null
+    return { chatId, resetAt: parsed.resetAt, tz: parsed.tz, raw: text }
+  }
+}
+
+interface JsonRpcErrorLike {
+  code?: number
+  message?: string
+  data?: Record<string, unknown>
+}
+
+export class CodexLimitDetector implements LimitDetector {
+  detect(chatId: string, error: unknown): LimitDetection | null {
+    if (!error || typeof error !== "object") return null
+    const rpc = error as JsonRpcErrorLike
+    const data = rpc.data && typeof rpc.data === "object" ? rpc.data : null
+    const isRateLimit = data?.code === "rate_limit" || rpc.code === -32001
+    if (!isRateLimit) return null
+
+    let resetAt: number | null = null
+    if (typeof data?.resets_at_ms === "number" && Number.isFinite(data.resets_at_ms)) {
+      resetAt = data.resets_at_ms
+    } else {
+      resetAt = parseIsoMillis(data?.resets_at)
+    }
+    if (resetAt === null) return null
+
+    const tz = typeof data?.timezone === "string" ? (data.timezone as string) : "system"
+    return { chatId, resetAt, tz, raw: error }
+  }
+}