saeeol 1.2.5 → 1.2.8

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

@@ -1,367 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,142 +0,0 @@
-/**
- * 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()
-  })
-})