@knpkv/jira-cli 0.1.1 → 0.3.0

package/src/internal/oauthServer.ts

@@ -10,21 +10,20 @@
  *
  * @internal
  */
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServer from "@effect/platform/HttpServer"
-import type { ServeError } from "@effect/platform/HttpServerError"
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import { OAuthError } from "@knpkv/atlassian-common/auth"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
 import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import { HttpRouter, HttpServer, HttpServerResponse } from "effect/unstable/http"
+import type * as HttpServerError from "effect/unstable/http/HttpServerError"
 
 const DEFAULT_PORT = 8585
-const MAX_PORT_ATTEMPTS = 10
-
+const MAX_PORT = 8594
+type HttpServerInstance = Effect.Success<typeof HttpServer.HttpServer>
 /**
  * Factory service for creating HTTP servers.
  * This allows mocking the server creation in tests.
@@ -34,7 +33,7 @@ const MAX_PORT_ATTEMPTS = 10
 export interface HttpServerFactory {
   readonly createServerLayer: (port: number) => Layer.Layer<
     HttpServer.HttpServer,
-    ServeError,
+    HttpServerError.ServeError,
     never
   >
 }
@@ -44,10 +43,10 @@ export interface HttpServerFactory {
  *
  * @category Services
  */
-export class HttpServerFactoryTag extends Context.Tag("@knpkv/jira-cli/HttpServerFactory")<
+export class HttpServerFactoryTag extends Context.Service<
   HttpServerFactoryTag,
   HttpServerFactory
->() {}
+>()("@knpkv/jira-cli/HttpServerFactory") {}
 
 /**
  * Create a HttpServerFactory layer from a layer factory function.
@@ -59,50 +58,12 @@ export class HttpServerFactoryTag extends Context.Tag("@knpkv/jira-cli/HttpServe
  * @category Layers
  */
 export const makeHttpServerFactory = (
-  createLayerFn: (port: number) => Layer.Layer<HttpServer.HttpServer, ServeError, never>
+  createLayerFn: (port: number) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, never>
 ): Layer.Layer<HttpServerFactoryTag> =>
   Layer.succeed(HttpServerFactoryTag, {
     createServerLayer: createLayerFn
   })
 
-/**
- * Check if a port is available by attempting to start a server.
- */
-const isPortAvailable = (port: number): Effect.Effect<boolean, never, HttpServerFactoryTag> =>
-  Effect.gen(function*() {
-    const factory = yield* HttpServerFactoryTag
-    const serverLayer = factory.createServerLayer(port)
-
-    const result = yield* Layer.build(serverLayer).pipe(
-      Effect.scoped,
-      Effect.as(true),
-      Effect.catchAll(() => Effect.succeed(false))
-    )
-    return result
-  })
-
-/**
- * Find an available port starting from the default.
- */
-const findAvailablePort = (): Effect.Effect<number, OAuthError, HttpServerFactoryTag> =>
-  Effect.gen(function*() {
-    for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
-      const port = DEFAULT_PORT + attempt
-      const available = yield* isPortAvailable(port)
-      if (available) {
-        return port
-      }
-    }
-    return yield* Effect.fail(
-      new OAuthError({
-        step: "authorize",
-        cause: `Could not find available port (tried ${DEFAULT_PORT}-${
-          DEFAULT_PORT + MAX_PORT_ATTEMPTS - 1
-        }). Close other applications using these ports.`
-      })
-    )
-  })
-
 /**
  * Result from the OAuth callback server.
  */
@@ -128,15 +89,32 @@ export const startCallbackServer = (
 ): Effect.Effect<CallbackServerResult, OAuthError, HttpServerFactoryTag> =>
   Effect.gen(function*() {
     const factory = yield* HttpServerFactoryTag
-    const port = yield* findAvailablePort()
     const deferred = yield* Deferred.make<string, OAuthError>()
-    const readyDeferred = yield* Deferred.make<void, OAuthError>()
-
-    const app = HttpRouter.empty.pipe(
-      HttpRouter.get(
-        "/callback",
+    const serverScope = yield* Scope.make()
+    const buildServerContext = (port: number): Effect.Effect<
+      { readonly context: Context.Context<HttpServer.HttpServer>; readonly port: number },
+      OAuthError
+    > =>
+      Layer.buildWithScope(factory.createServerLayer(port), serverScope).pipe(
+        Effect.map((context) => ({ context, port })),
+        Effect.catchCause((cause) =>
+          port < MAX_PORT
+            ? buildServerContext(port + 1)
+            : Effect.fail(new OAuthError({ step: "authorize", cause }))
+        )
+      )
+    const { context: serverContext } = yield* buildServerContext(DEFAULT_PORT)
+    const server: HttpServerInstance = Context.get(serverContext, HttpServer.HttpServer)
+    const port = yield* (server.address._tag === "TcpAddress"
+      ? Effect.succeed(server.address.port)
+      : Effect.fail(new OAuthError({ step: "authorize", cause: "OAuth callback server must listen on a TCP port" })))
+
+    const router = yield* HttpRouter.make
+    yield* router.add(
+      "GET",
+      "/callback",
+      (req) =>
         Effect.gen(function*() {
-          const req = yield* HttpServerRequest.HttpServerRequest
           const url = new URL(req.url, `http://localhost:${port}`)
           const code = url.searchParams.get("code")
           const state = url.searchParams.get("state")
@@ -178,26 +156,21 @@ export const startCallbackServer = (
             "<html><body><h1>Success!</h1><p>You can close this window and return to the terminal.</p></body></html>"
           )
         })
-      )
     )
+    const app = router.asHttpEffect()
 
-    const serverLayer = factory.createServerLayer(port)
-
-    const serverFiber = yield* HttpServer.serve(app).pipe(
-      Layer.provide(serverLayer),
-      Layer.build,
-      Effect.tap(() => Deferred.succeed(readyDeferred, undefined)),
-      Effect.tapError((err) => Deferred.fail(readyDeferred, new OAuthError({ step: "authorize", cause: err }))),
-      Effect.flatMap(() => Effect.never),
-      Effect.scoped,
-      Effect.fork
+    const serverFiber = yield* HttpServer.serveEffect(app).pipe(
+      Effect.provide(serverContext),
+      Effect.provideService(Scope.Scope, serverScope),
+      Effect.forkIn(serverScope)
     )
 
-    yield* Deferred.await(readyDeferred)
-
     return {
       codePromise: Deferred.await(deferred),
-      shutdown: Fiber.interrupt(serverFiber).pipe(Effect.asVoid),
+      shutdown: Effect.gen(function*() {
+        yield* Fiber.interrupt(serverFiber)
+        yield* Scope.close(serverScope, Exit.void)
+      }),
       port
     }
   })

package/src/internal/openBrowser.ts

@@ -0,0 +1,31 @@
+/**
+ * Cross-platform browser launcher backed by Effect v4 child process services.
+ *
+ * @internal
+ */
+import * as Effect from "effect/Effect"
+import type * as PlatformError from "effect/PlatformError"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+
+const run = (
+  command: string,
+  args: ReadonlyArray<string>
+): Effect.Effect<void, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner> =>
+  Effect.gen(function*() {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    yield* spawner.exitCode(
+      ChildProcess.make(command, args, {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore"
+      })
+    )
+  })
+
+export const openBrowser = (
+  url: string
+): Effect.Effect<void, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner> =>
+  run("open", [url]).pipe(
+    Effect.catch(() => run("xdg-open", [url])),
+    Effect.catch(() => run("rundll32.exe", ["url.dll,FileProtocolHandler", url]))
+  )

package/test/VersionService.test.ts

@@ -0,0 +1,266 @@
+import { describe, expect, it } from "@effect/vitest"
+import { JiraApiClient } from "@knpkv/jira-api-client"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { stripEmails } from "../src/commands/version.js"
+import type { Version } from "../src/VersionService.js"
+import {
+  extractContributorIds,
+  layer as VersionServiceLayer,
+  personFromObject,
+  renderCustomFieldValue,
+  toRelatedWork,
+  VersionService
+} from "../src/VersionService.js"
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+describe("renderCustomFieldValue", () => {
+  it("returns null for null/undefined/empty string", () => {
+    expect(renderCustomFieldValue(null)).toBeNull()
+    expect(renderCustomFieldValue(undefined)).toBeNull()
+    expect(renderCustomFieldValue("")).toBeNull()
+  })
+
+  it("returns plain strings and coerces numbers/booleans", () => {
+    expect(renderCustomFieldValue("hello")).toBe("hello")
+    expect(renderCustomFieldValue(42)).toBe("42")
+    expect(renderCustomFieldValue(true)).toBe("true")
+  })
+
+  it("renders cascading select as 'Parent > Child'", () => {
+    expect(renderCustomFieldValue({ value: "High", child: { value: "Confidential" } })).toBe(
+      "High > Confidential"
+    )
+  })
+
+  it("renders a single select / option as its value", () => {
+    expect(renderCustomFieldValue({ value: "High" })).toBe("High")
+  })
+
+  it("renders a user object as its display name", () => {
+    expect(renderCustomFieldValue({ displayName: "Jane Doe" })).toBe("Jane Doe")
+  })
+
+  it("falls back to name when no value/displayName", () => {
+    expect(renderCustomFieldValue({ name: "Backend" })).toBe("Backend")
+  })
+
+  it("joins arrays with ', ' and drops empties", () => {
+    expect(renderCustomFieldValue([{ value: "A" }, { value: "B" }])).toBe("A, B")
+    expect(renderCustomFieldValue([])).toBeNull()
+    expect(renderCustomFieldValue([null, ""])).toBeNull()
+  })
+
+  it("returns null for an unknown object shape", () => {
+    expect(renderCustomFieldValue({ foo: "bar" })).toBeNull()
+  })
+})
+
+describe("personFromObject", () => {
+  it("builds a Person from an object with accountId", () => {
+    expect(personFromObject({ accountId: "abc", displayName: "Jane", emailAddress: "jane@example.com" })).toEqual({
+      accountId: "abc",
+      displayName: "Jane",
+      emailAddress: "jane@example.com"
+    })
+  })
+
+  it("falls back displayName to accountId and email to null", () => {
+    expect(personFromObject({ accountId: "abc" })).toEqual({
+      accountId: "abc",
+      displayName: "abc",
+      emailAddress: null
+    })
+  })
+
+  it("uses fallbackId when the object has no accountId", () => {
+    expect(personFromObject({ displayName: "Jane" }, "fid")).toEqual({
+      accountId: "fid",
+      displayName: "Jane",
+      emailAddress: null
+    })
+  })
+
+  it("treats a bare string as an accountId", () => {
+    expect(personFromObject("abc")).toEqual({ accountId: "abc", displayName: "abc", emailAddress: null })
+  })
+
+  it("returns null with neither accountId nor fallback", () => {
+    expect(personFromObject({ displayName: "Jane" })).toBeNull()
+    expect(personFromObject(null)).toBeNull()
+    expect(personFromObject("")).toBeNull()
+  })
+})
+
+describe("extractContributorIds", () => {
+  it("returns [] when contributors is missing or not an array", () => {
+    expect(extractContributorIds({})).toEqual([])
+    expect(extractContributorIds({ contributors: "nope" })).toEqual([])
+  })
+
+  it("extracts ids from strings and objects, skipping empties", () => {
+    expect(
+      extractContributorIds({
+        contributors: ["a", { accountId: "b" }, { accountId: "" }, {}, ""]
+      })
+    ).toEqual(["a", "b"])
+  })
+})
+
+describe("toRelatedWork", () => {
+  it("normalises a related-work entry", () => {
+    expect(
+      toRelatedWork({
+        relatedWorkId: "rw-1",
+        title: "Release notes",
+        category: "Communication",
+        url: "https://example.com"
+      })
+    ).toEqual({
+      relatedWorkId: "rw-1",
+      title: "Release notes",
+      category: "Communication",
+      url: "https://example.com"
+    })
+  })
+
+  it("defaults category to empty string and missing fields to null", () => {
+    expect(toRelatedWork({})).toEqual({
+      relatedWorkId: null,
+      title: null,
+      category: "",
+      url: null
+    })
+  })
+})
+
+describe("stripEmails", () => {
+  const versionWithEmails: Version = {
+    id: "10",
+    name: "1.0.0",
+    description: null,
+    released: true,
+    archived: false,
+    startDate: null,
+    releaseDate: "2026-01-01",
+    driver: { accountId: "d", displayName: "Dana", emailAddress: "dana@example.com" },
+    contributors: [
+      { accountId: "c1", displayName: "Cara", emailAddress: "cara@example.com" },
+      { accountId: "c2", displayName: "Cliff", emailAddress: "cliff@example.com" }
+    ],
+    approvers: [
+      {
+        person: { accountId: "a1", displayName: "Amy", emailAddress: "amy@example.com" },
+        status: "APPROVED",
+        declineReason: null,
+        description: null
+      }
+    ],
+    tickets: [
+      {
+        key: "PROJ-1",
+        summary: "Do thing",
+        assignee: { accountId: "t1", displayName: "Tom", emailAddress: "tom@example.com" },
+        labels: [],
+        customFields: {}
+      },
+      { key: "PROJ-2", summary: null, assignee: null, labels: [], customFields: {} }
+    ],
+    url: "https://x/version/10"
+  }
+
+  it("nulls every Person.emailAddress across driver, contributors, approvers and assignees", () => {
+    const stripped = stripEmails(versionWithEmails)
+    expect(stripped.driver?.emailAddress).toBeNull()
+    expect(stripped.contributors.map((c) => c.emailAddress)).toEqual([null, null])
+    expect(stripped.approvers.map((a) => a.person.emailAddress)).toEqual([null])
+    expect(stripped.tickets.map((t) => t.assignee?.emailAddress ?? null)).toEqual([null, null])
+  })
+
+  it("preserves non-email fields and overall shape", () => {
+    const stripped = stripEmails(versionWithEmails)
+    expect(stripped.driver?.displayName).toBe("Dana")
+    expect(stripped.contributors.map((c) => c.accountId)).toEqual(["c1", "c2"])
+    expect(stripped.approvers[0].status).toBe("APPROVED")
+    expect(stripped.tickets.map((t) => t.key)).toEqual(["PROJ-1", "PROJ-2"])
+  })
+
+  it("leaves emails intact when callers keep the original (opt-in path)", () => {
+    // The command emits the unmodified version when --emails is set; assert the
+    // original is untouched (stripEmails returns a copy, never mutating input).
+    expect(versionWithEmails.driver?.emailAddress).toBe("dana@example.com")
+    expect(versionWithEmails.tickets[0].assignee?.emailAddress).toBe("tom@example.com")
+  })
+
+  it("handles a null driver and null assignees without throwing", () => {
+    const stripped = stripEmails({ ...versionWithEmails, driver: null })
+    expect(stripped.driver).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// released / unreleased + cap filtering (via a stubbed client)
+// ---------------------------------------------------------------------------
+
+const versionsFixture = [
+  { id: "1", name: "1.0.0", released: true, self: "https://x/version/1" },
+  { id: "2", name: "2.0.0", released: false, self: "https://x/version/2" },
+  { id: "3", name: "3.0.0", released: true, self: "https://x/version/3" },
+  { id: "4", name: "4.0.0", released: false, self: "https://x/version/4" }
+]
+
+/**
+ * Build a JiraApiClient mock whose `v3.client.GET` routes by path: the version
+ * list endpoint returns the fixture; the JQL search endpoint returns no issues
+ * (so the contributor scan resolves to empty without further calls).
+ */
+const makeJiraLayer = () =>
+  Layer.succeed(JiraApiClient, {
+    v3: {
+      client: {
+        GET: (path: string) =>
+          path === "/rest/api/3/project/{projectIdOrKey}/version"
+            ? Promise.resolve({
+              data: { values: versionsFixture, isLast: true },
+              response: { ok: true, status: 200 }
+            })
+            : Promise.resolve({
+              data: { issues: [], isLast: true },
+              response: { ok: true, status: 200 }
+            })
+      }
+    }
+  } as never)
+
+describe("listProjectVersions filtering", () => {
+  it.effect("returns all versions when neither flag is set", () =>
+    Effect.gen(function*() {
+      const service = yield* VersionService
+      const list = yield* service.listProjectVersions("PROJ")
+      expect(list.map((v) => v.id)).toEqual(["1", "2", "3", "4"])
+    }).pipe(Effect.provide(VersionServiceLayer), Effect.provide(makeJiraLayer())))
+
+  it.effect("keeps only released versions when released=true", () =>
+    Effect.gen(function*() {
+      const service = yield* VersionService
+      const list = yield* service.listProjectVersions("PROJ", { released: true })
+      expect(list.map((v) => v.id)).toEqual(["1", "3"])
+    }).pipe(Effect.provide(VersionServiceLayer), Effect.provide(makeJiraLayer())))
+
+  it.effect("keeps only unreleased versions when unreleased=true", () =>
+    Effect.gen(function*() {
+      const service = yield* VersionService
+      const list = yield* service.listProjectVersions("PROJ", { unreleased: true })
+      expect(list.map((v) => v.id)).toEqual(["2", "4"])
+    }).pipe(Effect.provide(VersionServiceLayer), Effect.provide(makeJiraLayer())))
+
+  it.effect("caps the result count at maxResults", () =>
+    Effect.gen(function*() {
+      const service = yield* VersionService
+      const list = yield* service.listProjectVersions("PROJ", { maxResults: 2 })
+      expect(list.map((v) => v.id)).toEqual(["1", "2"])
+    }).pipe(Effect.provide(VersionServiceLayer), Effect.provide(makeJiraLayer())))
+})

package/vitest.config.ts

@@ -1,6 +1,11 @@
 import { defineConfig } from "vitest/config"
 
 export default defineConfig({
+  resolve: {
+    alias: {
+      "@knpkv/jira-api-client": new URL("../jira-api-client/src/index.ts", import.meta.url).pathname
+    }
+  },
   test: {
     include: ["test/**/*.test.ts"],
     globals: true,