saeeol 1.3.0 → 1.3.1

package/test/saeeol/sessions/remote-ws.test.ts

@@ -0,0 +1,367 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { RemoteWS } from "../../../src/sessions/remote-ws"
+import type { ServerWebSocket } from "bun"
+
+function nolog() {
+  return {
+    info: () => {},
+    error: () => {},
+    warn: () => {},
+  }
+}
+
+function capture() {
+  const calls: unknown[][] = []
+  return {
+    calls,
+    log: {
+      info: (...args: unknown[]) => calls.push(args),
+      error: (...args: unknown[]) => calls.push(args),
+      warn: (...args: unknown[]) => calls.push(args),
+    },
+  }
+}
+
+function createServer() {
+  const messages: string[] = []
+  const clients: ServerWebSocket<unknown>[] = []
+  const pending: {
+    connect: ((ws: ServerWebSocket<unknown>) => void)[]
+    message: ((msg: string) => void)[]
+  } = { connect: [], message: [] }
+
+  const server = Bun.serve({
+    port: 0,
+    fetch(req, server) {
+      const upgraded = server.upgrade(req)
+      if (!upgraded) return new Response("Not found", { status: 404 })
+      return undefined
+    },
+    websocket: {
+      open(ws) {
+        clients.push(ws)
+        const cb = pending.connect.shift()
+        cb?.(ws)
+      },
+      message(_ws, msg) {
+        const str = String(msg)
+        messages.push(str)
+        const cb = pending.message.shift()
+        cb?.(str)
+      },
+      close(ws) {
+        const idx = clients.indexOf(ws)
+        if (idx >= 0) clients.splice(idx, 1)
+      },
+    },
+  })
+
+  return {
+    url: `ws://localhost:${server.port}`,
+    messages,
+    clients,
+    stop: () => server.stop(true),
+    waitForConnect: () =>
+      new Promise<ServerWebSocket<unknown>>((resolve) => {
+        pending.connect.push(resolve)
+      }),
+    waitForMessage: () =>
+      new Promise<string>((resolve) => {
+        pending.message.push(resolve)
+      }),
+  }
+}
+
+async function settled() {
+  await Bun.sleep(20)
+}
+
+describe("RemoteWS", () => {
+  let server: ReturnType<typeof createServer>
+  let conn: RemoteWS.Connection | undefined
+
+  afterEach(() => {
+    conn?.close()
+    conn = undefined
+    server?.stop()
+  })
+
+  test("connects and sends heartbeat", async () => {
+    server = createServer()
+    const connecting = server.waitForConnect()
+    const msg = server.waitForMessage()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [{ id: "s1", status: "active", title: "Test" }] }),
+      log: nolog(),
+      heartbeat: 100,
+    })
+
+    await connecting
+    await settled()
+    expect(conn.connected).toBe(true)
+
+    const raw = await msg
+    const parsed = JSON.parse(raw)
+    expect(parsed.type).toBe("heartbeat")
+    expect(parsed.sessions).toEqual([{ id: "s1", status: "active", title: "Test" }])
+  })
+
+  test("buffers when disconnected, flushes on reconnect", async () => {
+    server = createServer()
+    const connecting = server.waitForConnect()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+    })
+
+    await connecting
+    await settled()
+
+    for (const ws of [...server.clients]) ws.close()
+    await Bun.sleep(50)
+
+    expect(conn.connected).toBe(false)
+
+    conn.send({ type: "event", sessionId: "s1", event: "test", data: { a: 1 } })
+    conn.send({ type: "event", sessionId: "s2", event: "test", data: { b: 2 } })
+
+    const msg1 = server.waitForMessage()
+    const msg2 = server.waitForMessage()
+    await server.waitForConnect()
+    await settled()
+
+    const r1 = JSON.parse(await msg1)
+    const r2 = JSON.parse(await msg2)
+    expect(r1.sessionId).toBe("s1")
+    expect(r2.sessionId).toBe("s2")
+  })
+
+  test("reconnects with backoff after server close", async () => {
+    server = createServer()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+    })
+
+    const ws1 = await server.waitForConnect()
+    await settled()
+
+    const reconnecting = server.waitForConnect()
+    ws1.close()
+    await Bun.sleep(50)
+
+    expect(conn.connected).toBe(false)
+
+    const ws2 = await reconnecting
+    expect(ws2).toBeDefined()
+    await settled()
+    expect(conn.connected).toBe(true)
+  })
+
+  test("stops reconnecting on 4401", async () => {
+    server = createServer()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+    })
+
+    const ws1 = await server.waitForConnect()
+    await settled()
+
+    ws1.close(4401, "unauthorized")
+
+    await Bun.sleep(2000)
+
+    expect(conn.connected).toBe(false)
+    expect(server.clients.length).toBe(0)
+  })
+
+  test("onClose callback fires on permanent close", async () => {
+    server = createServer()
+    const codes: number[] = []
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+      onClose: (code) => codes.push(code),
+    })
+
+    const ws1 = await server.waitForConnect()
+    await settled()
+
+    ws1.close(4401, "unauthorized")
+    await Bun.sleep(100)
+
+    expect(codes).toEqual([4401])
+    expect(conn.connected).toBe(false)
+  })
+
+  test("incoming message delivered to onMessage", async () => {
+    server = createServer()
+    const received: unknown[] = []
+    const cap = capture()
+    const secret = "user secret prompt"
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: cap.log,
+      heartbeat: 60_000,
+      onMessage: (msg) => received.push(msg),
+    })
+
+    const ws = await server.waitForConnect()
+    await settled()
+
+    ws.send(
+      JSON.stringify({
+        type: "command",
+        id: "c1",
+        command: "send_message",
+        sessionId: "s1",
+        data: { text: secret },
+      }),
+    )
+
+    await Bun.sleep(50)
+    expect(received.length).toBe(1)
+    expect(received[0]).toEqual({
+      type: "command",
+      id: "c1",
+      command: "send_message",
+      sessionId: "s1",
+      data: { text: secret },
+    })
+
+    const seen = JSON.stringify(cap.calls)
+    expect(seen.includes(secret)).toBe(false)
+    expect(cap.calls).toContainEqual(["remote-ws received", { bytes: expect.any(Number), type: "command", id: "c1" }])
+  })
+
+  test("close() prevents further reconnection and stops heartbeat", async () => {
+    server = createServer()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [{ id: "s1", status: "active", title: "Test" }] }),
+      log: nolog(),
+      heartbeat: 100,
+    })
+
+    await server.waitForConnect()
+    await settled()
+
+    // Drain initial heartbeat message(s)
+    server.messages.length = 0
+
+    conn.close()
+    conn = undefined
+
+    // Wait long enough for heartbeat and reconnect if they were still running
+    await Bun.sleep(500)
+
+    // No new connections and no new heartbeat messages
+    expect(server.clients.length).toBe(0)
+    expect(server.messages.length).toBe(0)
+  })
+
+  test("force-reconnects on activity timeout", async () => {
+    server = createServer()
+    const ws1 = server.waitForConnect()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+      timeout: 200,
+    })
+
+    await ws1
+    await settled()
+    expect(conn.connected).toBe(true)
+
+    // Don't send any server messages — timeout should fire
+    const ws2 = server.waitForConnect()
+    await Bun.sleep(450)
+
+    // Should have reconnected
+    await ws2
+    await settled()
+    expect(conn.connected).toBe(true)
+  })
+
+  test("resets activity timer on incoming messages", async () => {
+    server = createServer()
+    const ws1p = server.waitForConnect()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+      timeout: 300,
+    })
+
+    const ws1 = await ws1p
+    await settled()
+
+    // Send server messages at 100ms intervals — each resets the timer
+    for (let i = 0; i < 4; i++) {
+      await Bun.sleep(100)
+      ws1.send(JSON.stringify({ type: "subscribe", sessionId: `s${i}` }))
+    }
+
+    await settled()
+    // Connection should still be alive — activity kept resetting the timer
+    expect(conn.connected).toBe(true)
+    expect(server.clients.length).toBe(1)
+  })
+
+  test("activity timeout uses custom timeout option", async () => {
+    server = createServer()
+    const ws1 = server.waitForConnect()
+
+    conn = RemoteWS.connect({
+      url: server.url,
+      getToken: async () => "tok",
+      getSessions: async () => ({ sessions: [] }),
+      log: nolog(),
+      heartbeat: 60_000,
+      timeout: 100,
+    })
+
+    await ws1
+    await settled()
+
+    // With 100ms timeout, should reconnect faster than default 30s
+    const ws2 = server.waitForConnect()
+    await Bun.sleep(250)
+
+    await ws2
+    await settled()
+    expect(conn.connected).toBe(true)
+  })
+})

package/test/saeeol/sessions/sessions-enable-remote.test.disable

@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
+import { tmpdir } from "../../fixture/fixture"
+import { Auth } from "../../../src/auth"
+import { Vcs } from "../../../src/project/vcs"
+import { RemoteWS } from "../../../src/kilo-sessions/remote-ws"
+import { RemoteSender } from "../../../src/kilo-sessions/remote-sender"
+import { clearInFlightCache } from "../../../src/kilo-sessions/inflight-cache"
+import { KiloSessions } from "../../../src/kilo-sessions/kilo-sessions"
+import { Instance } from "../../../src/project/instance"
+import { Bus } from "../../../src/bus"
+
+const state = {
+  connects: 0,
+  closes: 0,
+  disposes: 0,
+  userStatus: 200,
+  gate: Promise.resolve(),
+  userError: false,
+}
+
+describe("KiloSessions.enableRemote", () => {
+  beforeEach(() => {
+    state.connects = 0
+    state.closes = 0
+    state.disposes = 0
+    state.userStatus = 200
+    state.gate = Promise.resolve()
+    state.userError = false
+    process.env["KILO_DISABLE_SESSION_INGEST"] = "0"
+    delete process.env["SAEEOLCODE_SESSION_INGEST_URL"]
+
+    spyOn(Auth, "get").mockResolvedValue({ type: "api", key: "tok" } as any)
+    spyOn(Vcs, "branch").mockResolvedValue("main")
+    spyOn(RemoteWS, "connect").mockImplementation(
+      () =>
+        ({
+          connectionId: `conn-${++state.connects}`,
+          send() {},
+          close() {
+            state.closes += 1
+          },
+          get connected() {
+            return true
+          },
+        }) as RemoteWS.Connection,
+    )
+    spyOn(RemoteSender, "create").mockImplementation(
+      () =>
+        ({
+          handle() {},
+          dispose() {
+            state.disposes += 1
+          },
+        }) as RemoteSender.Sender,
+    )
+
+    // Clear inflight caches so each test gets fresh Auth.get / authValid calls
+    clearInFlightCache("kilo-sessions:token")
+    clearInFlightCache("kilo-sessions:token-valid:tok")
+
+    globalThis.fetch = mock(async (input) => {
+      await state.gate
+      if (String(input).endsWith("/api/user")) {
+        if (state.userError) throw new Error("network down")
+        return new Response(null, { status: state.userStatus })
+      }
+      return new Response(null, { status: 200 })
+    }) as unknown as typeof fetch
+  })
+
+  afterEach(() => {
+    // Stub Bus.publish so disableRemote's fire-and-forget publish doesn't reject
+    // outside an Instance context (it needs InstanceState which requires ALS).
+    const pub = spyOn(Bus, "publish").mockResolvedValue(undefined as never)
+    KiloSessions.disableRemote()
+    pub.mockRestore()
+    mock.restore()
+  })
+
+  test("concurrent enableRemote shares one connection", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        await Promise.all([KiloSessions.enableRemote(), KiloSessions.enableRemote(), KiloSessions.enableRemote()])
+        expect(state.connects).toBe(1)
+        expect(KiloSessions.remoteStatus()).toEqual({ enabled: true, connected: true })
+      },
+    })
+  })
+
+  test("enableRemote fails when token is invalid", async () => {
+    state.userStatus = 401
+    await using tmp = await tmpdir({ git: true })
+
+    KiloSessions.disableRemote()
+    clearInFlightCache("kilo-sessions:token-valid:tok")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        await expect(KiloSessions.enableRemote()).rejects.toThrow(
+          "Unable to enable remote: invalid or expired Kilo credentials. Run `kilo auth login`.",
+        )
+        expect(state.connects).toBe(0)
+        expect(KiloSessions.remoteStatus()).toEqual({ enabled: false, connected: false })
+      },
+    })
+  })
+
+  test("disableRemote cancels in-flight enableRemote", async () => {
+    let release = () => {}
+    state.gate = new Promise<void>((resolve) => {
+      release = resolve
+    })
+
+    await using tmp = await tmpdir({ git: true })
+
+    clearInFlightCache("kilo-sessions:token-valid:tok")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const pending = KiloSessions.enableRemote()
+        KiloSessions.disableRemote()
+        release()
+        await pending
+        expect(state.connects).toBe(1)
+        expect(state.disposes).toBe(1)
+        expect(state.closes).toBe(1)
+        expect(KiloSessions.remoteStatus()).toEqual({ enabled: false, connected: false })
+      },
+    })
+  })
+
+  test("transient auth check failure is retryable and does not connect", async () => {
+    state.userError = true
+    await using tmp = await tmpdir({ git: true })
+
+    KiloSessions.disableRemote()
+    clearInFlightCache("kilo-sessions:token-valid:tok")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        await expect(KiloSessions.enableRemote()).rejects.toThrow(
+          "Unable to enable remote: failed to verify Kilo credentials.",
+        )
+        expect(state.connects).toBe(0)
+        expect(KiloSessions.remoteStatus()).toEqual({ enabled: false, connected: false })
+      },
+    })
+  })
+
+  test("disable then re-enable replaces stale pending connection", async () => {
+    let release = () => {}
+    state.gate = new Promise<void>((resolve) => {
+      release = resolve
+    })
+
+    await using tmp = await tmpdir({ git: true })
+
+    clearInFlightCache("kilo-sessions:token-valid:tok")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const first = KiloSessions.enableRemote()
+        KiloSessions.disableRemote()
+        const second = KiloSessions.enableRemote()
+        release()
+        await Promise.all([first, second])
+        expect(state.connects).toBe(2)
+        expect(state.disposes).toBe(1)
+        expect(state.closes).toBe(1)
+        expect(KiloSessions.remoteStatus()).toEqual({ enabled: true, connected: true })
+      },
+    })
+  })
+})

package/test/saeeol/slot-prop-reactivity.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Regression test for the Slot wrapper in plugin/slots.tsx.
+ *
+ * This test locks in two things:
+ *   1. A static invariant: the wrapper does NOT spread raw props (`...props`),
+ *      which would silently reintroduce the regression on refactors.
+ *   2. A runtime check: forwarding props through the same pattern used in
+ *      slots.tsx preserves reactivity for arbitrary props (not just children).
+ */
+
+import { describe, expect, test } from "bun:test"
+import fs from "node:fs"
+import path from "node:path"
+import { children, createEffect, createRoot, createSignal, mergeProps } from "solid-js"
+
+const SLOTS_FILE = path.resolve(import.meta.dir, "../../src/cli/cmd/tui/plugin/slots.tsx")
+
+describe("Slot wrapper preserves prop reactivity", () => {
+  test("slots.tsx does not use `{...props}` spread to forward props", () => {
+    // Spread on a plain object in Solid evaluates every prop once and freezes
+    // it. mergeProps (or a getter per prop) is required to keep reactivity.
+    const content = fs.readFileSync(SLOTS_FILE, "utf-8")
+    const wrapper = content.match(/export const Slot[\s\S]*?^}/m)?.[0] ?? ""
+    expect(wrapper).not.toBe("")
+    expect(wrapper).not.toMatch(/\.\.\.props/)
+  })
+
+  test("slots.tsx forwards props through mergeProps (or per-prop getters)", () => {
+    const content = fs.readFileSync(SLOTS_FILE, "utf-8")
+    const wrapper = content.match(/export const Slot[\s\S]*?^}/m)?.[0] ?? ""
+    const usesMergeProps = /mergeProps\s*\(/.test(wrapper)
+    expect(usesMergeProps).toBe(true)
+  })
+
+  test("mergeProps preserves reactivity of non-children props", () => {
+    // Simulates the exact pattern used in slots.tsx: resolve children via the
+    // `children()` helper and forward the rest via mergeProps. Non-children
+    // reactive props (like `visible`, `disabled`, `ref`) must keep tracking
+    // their source signals — otherwise the slot-internal consumer (opentui
+    // registry → plugin) sees a frozen initial value.
+    const [visible, setVisible] = createSignal(true)
+    const [disabled, setDisabled] = createSignal(false)
+    const refCalls: Array<string> = []
+    const refA = () => refCalls.push("a")
+    const refB = () => refCalls.push("b")
+    const [ref, setRef] = createSignal<() => void>(refA)
+
+    const seen: Array<{ visible: boolean; disabled: boolean }> = []
+    const refSeen: Array<() => void> = []
+
+    const dispose = createRoot((dispose) => {
+      // Pretend JSX: reactive props passed into the Slot wrapper.
+      const sourceProps = {
+        get visible() {
+          return visible()
+        },
+        get disabled() {
+          return disabled()
+        },
+        get ref() {
+          return ref()
+        },
+        children: "unused",
+      }
+
+      // This mirrors plugin/slots.tsx exactly.
+      const value = children(() => sourceProps.children)
+      const merged = mergeProps(sourceProps, {
+        get children() {
+          return value()
+        },
+      }) as typeof sourceProps
+
+      createEffect(() => {
+        seen.push({ visible: merged.visible, disabled: merged.disabled })
+      })
+      createEffect(() => {
+        refSeen.push(merged.ref)
+      })
+
+      return dispose
+    })
+
+    // Initial render tracked.
+    expect(seen).toEqual([{ visible: true, disabled: false }])
+    expect(refSeen.length).toBe(1)
+    expect(refSeen[0]).toBe(refA)
+
+    // Flip the source signals — the merged view must update.
+    setVisible(false)
+    expect(seen).toEqual([
+      { visible: true, disabled: false },
+      { visible: false, disabled: false },
+    ])
+
+    setDisabled(true)
+    expect(seen[seen.length - 1]).toEqual({ visible: false, disabled: true })
+
+    // Ref callback must also track through the wrapper — this is what makes
+    // the session prompt ref={bind} actually attach/re-attach correctly.
+    setRef(() => refB)
+    expect(refSeen.length).toBe(2)
+    expect(refSeen[1]).toBe(refB)
+
+    dispose()
+  })
+
+  test("plain `{...props}` spread does NOT preserve reactivity (proves the regression)", () => {
+    // Negative control: the exact bug we're guarding against. A spread into a
+    // plain object decouples the reactive source, so an effect on the copy
+    // only fires once.
+    const [visible, setVisible] = createSignal(true)
+    let fires = 0
+
+    const dispose = createRoot((dispose) => {
+      const sourceProps = {
+        get visible() {
+          return visible()
+        },
+      }
+
+      // BUG pattern — copies the value at evaluation time.
+      const frozen = { ...sourceProps } as { visible: boolean }
+
+      createEffect(() => {
+        // Touch frozen.visible to subscribe (but it's a static property now).
+        void frozen.visible
+        fires++
+      })
+
+      return dispose
+    })
+
+    expect(fires).toBe(1)
+    setVisible(false)
+    // A correctly reactive wrapper would have fired again; the frozen copy
+    // does not. Keeping this assertion documents why mergeProps is required.
+    expect(fires).toBe(1)
+
+    dispose()
+  })
+})