saeeol 1.2.5 → 1.2.7

package/test/auth/auth.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Auth } from "../../src/auth"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const node = CrossSpawnSpawner.defaultLayer
-
-const it = testEffect(Layer.mergeAll(Auth.defaultLayer, node))
-
-describe("Auth", () => {
-  it.live("set normalizes trailing slashes in keys", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const auth = yield* Auth.Service
-        yield* auth.set("https://example.com/", {
-          type: "wellknown",
-          key: "TOKEN",
-          token: "abc",
-        })
-        const data = yield* auth.all()
-        expect(data["https://example.com"]).toBeDefined()
-        expect(data["https://example.com/"]).toBeUndefined()
-      }),
-    ),
-  )
-
-  it.live("set cleans up pre-existing trailing-slash entry", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const auth = yield* Auth.Service
-        yield* auth.set("https://example.com/", {
-          type: "wellknown",
-          key: "TOKEN",
-          token: "old",
-        })
-        yield* auth.set("https://example.com", {
-          type: "wellknown",
-          key: "TOKEN",
-          token: "new",
-        })
-        const data = yield* auth.all()
-        const keys = Object.keys(data).filter((key) => key.includes("example.com"))
-        expect(keys).toEqual(["https://example.com"])
-        const entry = data["https://example.com"]!
-        expect(entry.type).toBe("wellknown")
-        if (entry.type === "wellknown") expect(entry.token).toBe("new")
-      }),
-    ),
-  )
-
-  it.live("remove deletes both trailing-slash and normalized keys", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const auth = yield* Auth.Service
-        yield* auth.set("https://example.com", {
-          type: "wellknown",
-          key: "TOKEN",
-          token: "abc",
-        })
-        yield* auth.remove("https://example.com/")
-        const data = yield* auth.all()
-        expect(data["https://example.com"]).toBeUndefined()
-        expect(data["https://example.com/"]).toBeUndefined()
-      }),
-    ),
-  )
-
-  it.live("set and remove are no-ops on keys without trailing slashes", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const auth = yield* Auth.Service
-        yield* auth.set("anthropic", {
-          type: "api",
-          key: "sk-test",
-        })
-        const data = yield* auth.all()
-        expect(data["anthropic"]).toBeDefined()
-        yield* auth.remove("anthropic")
-        const after = yield* auth.all()
-        expect(after["anthropic"]).toBeUndefined()
-      }),
-    ),
-  )
-})

package/test/bun/registry.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import semver from "semver"
-
-describe("semver guard for isOutdated", () => {
-  function isOutdated(cachedVersion: string, latestVersion: string | null): boolean {
-    if (!latestVersion) return false
-
-    if (!cachedVersion || (!semver.valid(cachedVersion) && !semver.validRange(cachedVersion))) {
-      return false
-    }
-    if (!latestVersion || !semver.valid(latestVersion)) {
-      return false
-    }
-
-    const isRange = /[\s^~*xX<>|=]/.test(cachedVersion)
-    if (isRange) return !semver.satisfies(latestVersion, cachedVersion)
-
-    return semver.lt(cachedVersion, latestVersion)
-  }
-
-  test("returns true when cached is older", () => {
-    expect(isOutdated("1.0.0", "2.0.0")).toBe(true)
-  })
-
-  test("returns false when cached is newer", () => {
-    expect(isOutdated("2.0.0", "1.0.0")).toBe(false)
-  })
-
-  test("returns false when equal", () => {
-    expect(isOutdated("1.0.0", "1.0.0")).toBe(false)
-  })
-
-  test("returns false when latest is null", () => {
-    expect(isOutdated("1.0.0", null)).toBe(false)
-  })
-
-  test("handles range in cached version", () => {
-    expect(isOutdated("^1.0.0", "1.5.0")).toBe(false) // 1.5.0 satisfies ^1.0.0
-    expect(isOutdated("^1.0.0", "2.0.0")).toBe(true) // 2.0.0 does not satisfy ^1.0.0
-  })
-  test("returns false for workspace:* cached version", () => {
-    expect(isOutdated("workspace:*", "1.0.0")).toBe(false)
-  })
-
-  test("returns false for invalid latest version", () => {
-    expect(isOutdated("1.0.0", "not-a-version")).toBe(false)
-  })
-
-  test("returns false for empty cached version", () => {
-    expect(isOutdated("", "1.0.0")).toBe(false)
-  })
-
-  test("returns false for 'latest' as cached version", () => {
-    expect(isOutdated("latest", "1.0.0")).toBe(false)
-  })
-
-  test("does not throw on any invalid input", () => {
-    expect(() => isOutdated("workspace:*", "1.0.0")).not.toThrow()
-    expect(() => isOutdated("1.0.0", "workspace:*")).not.toThrow()
-    expect(() => isOutdated("", "")).not.toThrow()
-    expect(() => isOutdated("latest", "latest")).not.toThrow()
-    expect(() => isOutdated("abc", "def")).not.toThrow()
-  })
-
-  test("handles prerelease versions correctly", () => {
-    expect(isOutdated("0.0.0-test-123", "1.0.0")).toBe(true)
-    expect(isOutdated("1.0.0-alpha", "1.0.0")).toBe(true)
-  })
-
-  test("real version comparison works", () => {
-    expect(isOutdated("0.2.141", "0.2.148")).toBe(true)
-    expect(isOutdated("0.2.148", "0.2.141")).toBe(false)
-    expect(isOutdated("7.1.23", "7.2.0")).toBe(true)
-  })
-})

package/test/bus/bus-effect.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Deferred, Effect, Layer, Schema, Stream } from "effect"
-import { Bus } from "../../src/bus"
-import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { disposeAllInstances, provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const TestEvent = {
-  Ping: BusEvent.define("test.effect.ping", Schema.Struct({ value: Schema.Number })),
-  Pong: BusEvent.define("test.effect.pong", Schema.Struct({ message: Schema.String })),
-}
-
-const node = CrossSpawnSpawner.defaultLayer
-
-const live = Layer.mergeAll(Bus.layer, node)
-
-const it = testEffect(live)
-
-describe("Bus (Effect-native)", () => {
-  it.live("publish + subscribe stream delivers events", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const bus = yield* Bus.Service
-        const received: number[] = []
-        const done = yield* Deferred.make<void>()
-
-        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-          Effect.sync(() => {
-            received.push(evt.properties.value)
-            if (received.length === 2) Deferred.doneUnsafe(done, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Effect.sleep("10 millis")
-        yield* bus.publish(TestEvent.Ping, { value: 1 })
-        yield* bus.publish(TestEvent.Ping, { value: 2 })
-        yield* Deferred.await(done)
-
-        expect(received).toEqual([1, 2])
-      }),
-    ),
-  )
-
-  it.live("subscribe filters by event type", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const bus = yield* Bus.Service
-        const pings: number[] = []
-        const done = yield* Deferred.make<void>()
-
-        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-          Effect.sync(() => {
-            pings.push(evt.properties.value)
-            Deferred.doneUnsafe(done, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Effect.sleep("10 millis")
-        yield* bus.publish(TestEvent.Pong, { message: "ignored" })
-        yield* bus.publish(TestEvent.Ping, { value: 42 })
-        yield* Deferred.await(done)
-
-        expect(pings).toEqual([42])
-      }),
-    ),
-  )
-
-  it.live("subscribeAll receives all types", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const bus = yield* Bus.Service
-        const types: string[] = []
-        const done = yield* Deferred.make<void>()
-
-        yield* Stream.runForEach(bus.subscribeAll(), (evt) =>
-          Effect.sync(() => {
-            types.push(evt.type)
-            if (types.length === 2) Deferred.doneUnsafe(done, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Effect.sleep("10 millis")
-        yield* bus.publish(TestEvent.Ping, { value: 1 })
-        yield* bus.publish(TestEvent.Pong, { message: "hi" })
-        yield* Deferred.await(done)
-
-        expect(types).toContain("test.effect.ping")
-        expect(types).toContain("test.effect.pong")
-      }),
-    ),
-  )
-
-  it.live("multiple subscribers each receive the event", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const bus = yield* Bus.Service
-        const a: number[] = []
-        const b: number[] = []
-        const doneA = yield* Deferred.make<void>()
-        const doneB = yield* Deferred.make<void>()
-
-        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-          Effect.sync(() => {
-            a.push(evt.properties.value)
-            Deferred.doneUnsafe(doneA, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-          Effect.sync(() => {
-            b.push(evt.properties.value)
-            Deferred.doneUnsafe(doneB, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Effect.sleep("10 millis")
-        yield* bus.publish(TestEvent.Ping, { value: 99 })
-        yield* Deferred.await(doneA)
-        yield* Deferred.await(doneB)
-
-        expect(a).toEqual([99])
-        expect(b).toEqual([99])
-      }),
-    ),
-  )
-
-  it.live("subscribeAll stream sees InstanceDisposed on disposal", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const types: string[] = []
-      const seen = yield* Deferred.make<void>()
-      const disposed = yield* Deferred.make<void>()
-
-      // Set up subscriber inside the instance
-      yield* Effect.gen(function* () {
-        const bus = yield* Bus.Service
-
-        yield* Stream.runForEach(bus.subscribeAll(), (evt) =>
-          Effect.sync(() => {
-            types.push(evt.type)
-            if (evt.type === TestEvent.Ping.type) Deferred.doneUnsafe(seen, Effect.void)
-            if (evt.type === Bus.InstanceDisposed.type) Deferred.doneUnsafe(disposed, Effect.void)
-          }),
-        ).pipe(Effect.forkScoped)
-
-        yield* Effect.sleep("10 millis")
-        yield* bus.publish(TestEvent.Ping, { value: 1 })
-        yield* Deferred.await(seen)
-      }).pipe(provideInstance(dir))
-
-      // Dispose from OUTSIDE the instance scope
-      yield* Effect.promise(disposeAllInstances)
-      yield* Deferred.await(disposed).pipe(Effect.timeout("2 seconds"))
-
-      expect(types).toContain("test.effect.ping")
-      expect(types).toContain(Bus.InstanceDisposed.type)
-    }),
-  )
-})

package/test/bus/bus-integration.test.ts

@@ -1,87 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Bus } from "../../src/bus"
-import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-const TestEvent = BusEvent.define("test.integration", Schema.Struct({ value: Schema.Number }))
-
-function withInstance(directory: string, fn: () => Promise<void>) {
-  return Instance.provide({ directory, fn })
-}
-
-describe("Bus integration: acquireRelease subscriber pattern", () => {
-  afterEach(() => disposeAllInstances())
-
-  test("subscriber via callback facade receives events and cleans up on unsub", async () => {
-    await using tmp = await tmpdir()
-    const received: number[] = []
-
-    await withInstance(tmp.path, async () => {
-      const unsub = Bus.subscribe(TestEvent, (evt) => {
-        received.push(evt.properties.value)
-      })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 1 })
-      await Bus.publish(TestEvent, { value: 2 })
-      await Bun.sleep(10)
-
-      expect(received).toEqual([1, 2])
-
-      unsub()
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 3 })
-      await Bun.sleep(10)
-
-      expect(received).toEqual([1, 2])
-    })
-  })
-
-  test("subscribeAll receives events from multiple types", async () => {
-    await using tmp = await tmpdir()
-    const received: Array<{ type: string; value?: number }> = []
-
-    const OtherEvent = BusEvent.define("test.other", Schema.Struct({ value: Schema.Number }))
-
-    await withInstance(tmp.path, async () => {
-      Bus.subscribeAll((evt) => {
-        received.push({ type: evt.type, value: evt.properties.value })
-      })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 10 })
-      await Bus.publish(OtherEvent, { value: 20 })
-      await Bun.sleep(10)
-    })
-
-    expect(received).toEqual([
-      { type: "test.integration", value: 10 },
-      { type: "test.other", value: 20 },
-    ])
-  })
-
-  test("subscriber cleanup on instance disposal interrupts the stream", async () => {
-    await using tmp = await tmpdir()
-    const received: number[] = []
-    let disposed = false
-
-    await withInstance(tmp.path, async () => {
-      Bus.subscribeAll((evt) => {
-        if (evt.type === Bus.InstanceDisposed.type) {
-          disposed = true
-          return
-        }
-        received.push(evt.properties.value)
-      })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 1 })
-      await Bun.sleep(10)
-    })
-
-    await disposeAllInstances()
-    await Bun.sleep(50)
-
-    expect(received).toEqual([1])
-    expect(disposed).toBe(true)
-  })
-})

package/test/bus/bus.test.ts

@@ -1,219 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Bus } from "../../src/bus"
-import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-const TestEvent = {
-  Ping: BusEvent.define("test.ping", Schema.Struct({ value: Schema.Number })),
-  Pong: BusEvent.define("test.pong", Schema.Struct({ message: Schema.String })),
-}
-
-function withInstance(directory: string, fn: () => Promise<void>) {
-  return Instance.provide({ directory, fn })
-}
-
-describe("Bus", () => {
-  afterEach(() => disposeAllInstances())
-
-  describe("publish + subscribe", () => {
-    test("subscriber is live immediately after subscribe returns", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          received.push(evt.properties.value)
-        })
-        await Bus.publish(TestEvent.Ping, { value: 42 })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual([42])
-    })
-
-    test("subscriber receives matching events", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          received.push(evt.properties.value)
-        })
-        // Give the subscriber fiber time to start consuming
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 42 })
-        await Bus.publish(TestEvent.Ping, { value: 99 })
-        // Give subscriber time to process
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual([42, 99])
-    })
-
-    test("subscriber does not receive events of other types", async () => {
-      await using tmp = await tmpdir()
-      const pings: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          pings.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Pong, { message: "hello" })
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      expect(pings).toEqual([1])
-    })
-
-    test("publish with no subscribers does not throw", async () => {
-      await using tmp = await tmpdir()
-
-      await withInstance(tmp.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-      })
-    })
-  })
-
-  describe("unsubscribe", () => {
-    test("unsubscribe stops delivery", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        const unsub = Bus.subscribe(TestEvent.Ping, (evt) => {
-          received.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-        unsub()
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual([1])
-    })
-  })
-
-  describe("subscribeAll", () => {
-    test("subscribeAll is live immediately after subscribe returns", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual(["test.ping"])
-    })
-
-    test("receives all event types", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bus.publish(TestEvent.Pong, { message: "hi" })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toContain("test.ping")
-      expect(received).toContain("test.pong")
-    })
-  })
-
-  describe("multiple subscribers", () => {
-    test("all subscribers for same event type are called", async () => {
-      await using tmp = await tmpdir()
-      const a: number[] = []
-      const b: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          a.push(evt.properties.value)
-        })
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          b.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 7 })
-        await Bun.sleep(10)
-      })
-
-      expect(a).toEqual([7])
-      expect(b).toEqual([7])
-    })
-  })
-
-  describe("instance isolation", () => {
-    test("events in one directory do not reach subscribers in another", async () => {
-      await using tmpA = await tmpdir()
-      await using tmpB = await tmpdir()
-      const receivedA: number[] = []
-      const receivedB: number[] = []
-
-      await withInstance(tmpA.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          receivedA.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpB.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          receivedB.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpA.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpB.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
-
-      expect(receivedA).toEqual([1])
-      expect(receivedB).toEqual([2])
-    })
-  })
-
-  describe("instance disposal", () => {
-    test("InstanceDisposed is delivered to wildcard subscribers before stream ends", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      // disposeAllInstances triggers the finalizer which publishes InstanceDisposed
-      await disposeAllInstances()
-      await Bun.sleep(50)
-
-      expect(received).toContain("test.ping")
-      expect(received).toContain(Bus.InstanceDisposed.type)
-    })
-  })
-})

package/test/cli/account.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import stripAnsi from "strip-ansi"
-
-import { formatAccountLabel, formatOrgLine } from "../../src/cli/cmd/account"
-
-describe("console account display", () => {
-  test("includes the account url in account labels", () => {
-    expect(stripAnsi(formatAccountLabel({ email: "one@example.com", url: "https://one.example.com" }, false))).toBe(
-      "one@example.com https://one.example.com",
-    )
-  })
-
-  test("includes the active marker in account labels", () => {
-    expect(stripAnsi(formatAccountLabel({ email: "one@example.com", url: "https://one.example.com" }, true))).toBe(
-      "one@example.com https://one.example.com (active)",
-    )
-  })
-
-  test("includes the account url in org rows", () => {
-    expect(
-      stripAnsi(
-        formatOrgLine({ email: "one@example.com", url: "https://one.example.com" }, { id: "org-1", name: "One" }, true),
-      ),
-    ).toBe("  ● One  one@example.com  https://one.example.com  org-1")
-  })
-})