@knpkv/jira-cli 1.2.3 → 1.4.0

package/src/internal/oauthServer.ts

@@ -14,11 +14,12 @@ 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 { HttpRouter, HttpServer, HttpServerResponse } from "effect/http"
+import type * as HttpServerError from "effect/http/HttpServerError"
 import * as Layer from "effect/Layer"
+import { NetAddress } from "effect/net"
 import * as Schema from "effect/Schema"
 import type * 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 = 8594
@@ -30,13 +31,25 @@ type HttpServerInstance = Effect.Success<typeof HttpServer.HttpServer>
  * @category Services
  */
 export interface HttpServerFactory {
-  readonly createServerLayer: (port: number) => Layer.Layer<
+  readonly createServerLayer: (options: CallbackServerListenOptions) => Layer.Layer<
     HttpServer.HttpServer,
     HttpServerError.ServeError,
     never
   >
 }
 
+export interface CallbackServerListenOptions {
+  readonly host: "localhost"
+  readonly port: number
+}
+
+export const callbackServerListenOptions = (port: number): CallbackServerListenOptions => ({
+  host: "localhost",
+  port
+})
+
+export const callbackUrl = (port: number): string => `http://localhost:${port}/callback`
+
 /**
  * Tag for the HttpServerFactory service.
  *
@@ -57,7 +70,9 @@ export class HttpServerFactoryTag extends Context.Service<
  * @category Layers
  */
 export const makeHttpServerFactory = (
-  createLayerFn: (port: number) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, never>
+  createLayerFn: (
+    options: CallbackServerListenOptions
+  ) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, never>
 ): Layer.Layer<HttpServerFactoryTag> =>
   Layer.succeed(HttpServerFactoryTag, {
     createServerLayer: createLayerFn
@@ -98,7 +113,7 @@ export const startCallbackServer = (
       { readonly context: Context.Context<HttpServer.HttpServer>; readonly port: number },
       OAuthError
     > =>
-      Layer.buildWithScope(factory.createServerLayer(port), serverScope).pipe(
+      Layer.buildWithScope(factory.createServerLayer(callbackServerListenOptions(port)), serverScope).pipe(
         Effect.map((context) => ({ context, port })),
         Effect.catchIf(
           (error) => isAddressInUse(error) && port < MAX_PORT,
@@ -108,7 +123,7 @@ export const startCallbackServer = (
       )
     const { context: serverContext } = yield* buildServerContext(DEFAULT_PORT)
     const server: HttpServerInstance = Context.get(serverContext, HttpServer.HttpServer)
-    const port = yield* (server.address._tag === "TcpAddress"
+    const port = yield* (NetAddress.isInetAddress(server.address)
       ? Effect.succeed(server.address.port)
       : Effect.fail(new OAuthError({ step: "authorize", cause: "OAuth callback server must listen on a TCP port" })))
 
@@ -118,29 +133,27 @@ export const startCallbackServer = (
       "/callback",
       (req) =>
         Effect.gen(function*() {
-          const url = new URL(req.url, `http://localhost:${port}`)
+          const url = new URL(req.url, callbackUrl(port))
           const code = url.searchParams.get("code")
           const state = url.searchParams.get("state")
           const error = url.searchParams.get("error")
           const errorDescription = url.searchParams.get("error_description")
 
-          if (error) {
-            yield* Deferred.fail(
-              deferred,
-              new OAuthError({ step: "authorize", cause: errorDescription ?? error })
-            )
+          if (state !== expectedState) {
             return HttpServerResponse.html(
-              "<html><body><h1>Authorization Failed</h1><p>You can close this window.</p></body></html>"
+              "<html><body><h1>Security Error</h1><p>State verification failed.</p></body></html>"
+            ).pipe(
+              HttpServerResponse.setStatus(403)
             )
           }
 
-          if (state !== expectedState) {
+          if (error) {
             yield* Deferred.fail(
               deferred,
-              new OAuthError({ step: "authorize", cause: "State mismatch - possible CSRF attack" })
+              new OAuthError({ step: "authorize", cause: errorDescription ?? error })
             )
             return HttpServerResponse.html(
-              "<html><body><h1>Security Error</h1><p>State verification failed.</p></body></html>"
+              "<html><body><h1>Authorization Failed</h1><p>You can close this window.</p></body></html>"
             )
           }
 

package/src/internal/openBrowser.ts

@@ -5,7 +5,7 @@
  */
 import * as Effect from "effect/Effect"
 import type * as PlatformError from "effect/PlatformError"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { ChildProcess, ChildProcessSpawner } from "effect/process"
 
 const run = (
   command: string,

package/src/internal/sync/baseline.ts

@@ -15,7 +15,7 @@ export const parseSyncBaseline = (
 ): Effect.Effect<SyncBaseline, SyncWorkspaceError | SyncValidationError> =>
   Effect.gen(function*() {
     const raw = yield* Effect.try({
-      try: (): unknown => JSON.parse(content),
+      try: () => Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Json))(content),
       catch: (cause) => new SyncWorkspaceError({ message: "Failed to parse Sync Baseline JSON", path, cause })
     })
     const baseline: SyncBaseline = yield* Schema.decodeUnknownEffect(SyncBaselineSchema)(raw).pipe(
@@ -24,4 +24,5 @@ export const parseSyncBaseline = (
     return baseline
   })
 
-export const serializeSyncBaseline = (baseline: SyncBaseline): string => `${JSON.stringify(baseline, null, 2)}\n`
+export const serializeSyncBaseline = (baseline: SyncBaseline): string =>
+  `${JSON.stringify(Schema.encodeSync(SyncBaselineSchema)(baseline), null, 2)}\n`

package/src/internal/sync/config.ts

@@ -28,7 +28,8 @@ export const parseWorkspaceConfig = (
     return config
   })
 
-export const serializeWorkspaceConfig = (config: WorkspaceConfig): string => yaml.dump(config, { lineWidth: 100 })
+export const serializeWorkspaceConfig = (config: WorkspaceConfig): string =>
+  yaml.dump(Schema.encodeSync(WorkspaceConfigSchema)(config), { lineWidth: 100 })
 
 export const makeDefaultWorkspaceConfig = (siteUrl: string): WorkspaceConfig => ({
   version: 1,

package/src/internal/sync/document.ts

@@ -5,6 +5,7 @@
  */
 import { isPreviewableAttachment } from "@knpkv/atlassian-common/attachments"
 import * as Predicate from "effect/Predicate"
+import type * as Schema from "effect/Schema"
 import matter from "gray-matter"
 import * as yaml from "js-yaml"
 import { SyncValidationError } from "../../JiraCliError.js"
@@ -17,19 +18,19 @@ import type {
   UserFieldValue
 } from "./types.js"
 
-const isStringArray = (value: unknown): value is ReadonlyArray<string> =>
-  Array.isArray(value) && value.every((item) => typeof item === "string")
+const isStringArray = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & ReadonlyArray<string> =>
+  Array.isArray(value) && value.every((item) => Predicate.isString(item))
 
-const isFrontMatterCustomFields = (
-  value: unknown
-): value is IssueDocumentFrontMatter["customFields"] => Predicate.isReadonlyObject(value)
+const isFrontMatterCustomFields = <UnparsedInput>(
+  value: UnparsedInput
+): value is UnparsedInput & IssueDocumentFrontMatter["customFields"] => Predicate.isReadonlyObject(value)
 
 const yamlEngine = {
   parse: (str: string): object => {
     const value = yaml.load(str)
     return Predicate.isReadonlyObject(value) ? value : {}
   },
-  stringify: (data: object): string => yaml.dump(data)
+  stringify: <Data extends object>(data: Data): string => yaml.dump(data)
 }
 
 export const DESCRIPTION_SECTION = "Description"
@@ -88,17 +89,17 @@ const section = (name: string, content: string): string => {
   return normalized.length > 0 ? `## ${name}\n\n${normalized}\n` : `## ${name}\n`
 }
 
-const parseFrontMatter = (path: string, data: Record<string, unknown>): IssueDocumentFrontMatter => {
+const parseFrontMatter = (path: string, data: Record<string, Schema.Json>): IssueDocumentFrontMatter => {
   const requiredString = (key: string): string => {
     const value = data[key]
-    if (typeof value === "string") return value
+    if (Predicate.isString(value)) return value
     return fail(path, `Missing or invalid front matter field "${key}"`)
   }
 
   const nullableString = (key: string): string | null => {
     const value = data[key]
     if (value === null || value === undefined) return null
-    if (typeof value === "string") return value
+    if (Predicate.isString(value)) return value
     return fail(path, `Invalid front matter field "${key}"`)
   }
 
@@ -108,7 +109,7 @@ const parseFrontMatter = (path: string, data: Record<string, unknown>): IssueDoc
     const record = Predicate.isReadonlyObject(value) ? value : fail(path, `Invalid user field "${key}"`)
     const accountId = record["accountId"]
     const displayName = record["displayName"]
-    if (typeof accountId === "string" && typeof displayName === "string") {
+    if (Predicate.isString(accountId) && Predicate.isString(displayName)) {
       return {
         accountId,
         displayName
@@ -244,13 +245,13 @@ const parseAttachmentMetadata = (
     const parsed = JSON.parse(raw)
     if (!Predicate.isReadonlyObject(parsed)) return {}
     return {
-      id: typeof parsed["jiraAttachmentId"] === "string"
+      id: Predicate.isString(parsed["jiraAttachmentId"])
         ? parsed["jiraAttachmentId"]
-        : typeof parsed["id"] === "string"
+        : Predicate.isString(parsed["id"])
         ? parsed["id"]
         : "",
-      mediaType: typeof parsed["mediaType"] === "string" ? parsed["mediaType"] : null,
-      size: typeof parsed["size"] === "number" ? parsed["size"] : null
+      mediaType: Predicate.isString(parsed["mediaType"]) ? parsed["mediaType"] : null,
+      size: Predicate.isNumber(parsed["size"]) ? parsed["size"] : null
     }
   } catch {
     return {}

package/src/internal/sync/fieldValues.ts

@@ -16,7 +16,7 @@ export interface CanonicalFieldValueOptions {
 
 export const explicitClear = null
 
-export const isExplicitClear = (value: unknown): value is null => value === null
+export const isExplicitClear = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & null => value === null
 
 export const userFieldValue = (accountId: string, displayName: string): UserFieldValue => ({
   accountId,
@@ -44,24 +44,26 @@ export const completeListValue = (
 
 export const makeCompleteListValue = completeListValue
 
-export const isUserFieldValue = (value: unknown): value is UserFieldValue => {
+export const isUserFieldValue = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & UserFieldValue => {
   if (!Predicate.isReadonlyObject(value)) return false
-  return typeof value["accountId"] === "string" && typeof value["displayName"] === "string"
+  return Predicate.isString(value["accountId"]) && Predicate.isString(value["displayName"])
 }
 
-export const isOptionFieldValue = (value: unknown): value is OptionFieldValue => {
-  if (!Predicate.isReadonlyObject(value) || typeof value["value"] !== "string") return false
+export const isOptionFieldValue = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & OptionFieldValue => {
+  if (!Predicate.isReadonlyObject(value) || !Predicate.isString(value["value"])) return false
   const id = value["id"]
-  return id === undefined || typeof id === "string"
+  return id === undefined || Predicate.isString(id)
 }
 
-export const isCascadingFieldValue = (value: unknown): value is CascadingFieldValue => {
+export const isCascadingFieldValue = <UnparsedInput>(
+  value: UnparsedInput
+): value is UnparsedInput & CascadingFieldValue => {
   if (!Predicate.isReadonlyObject(value) || !isOptionFieldValue(value["parent"])) return false
   const child = value["child"]
   return child === undefined || isOptionFieldValue(child)
 }
 
-export const isCompleteListValue = (value: unknown): value is CompleteListValue =>
+export const isCompleteListValue = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & CompleteListValue =>
   Array.isArray(value) && value.every(isCompleteListItem)
 
 export const canonicalFieldOrder = <A extends CompleteListItem>(
@@ -104,7 +106,7 @@ const canonicalFieldValueKey = (
   options: CanonicalFieldValueOptions
 ): string => {
   if (value === null) return "clear:"
-  if (Array.isArray(value)) {
+  if (isCompleteListValue(value)) {
     return `list:${canonicalFieldOrder(value, options).map(completeListItemOrderKey).join("\u0000")}`
   }
   if (isCascadingFieldValue(value)) {
@@ -114,13 +116,13 @@ const canonicalFieldValueKey = (
   }
   if (isUserFieldValue(value)) return userOrderKey(value)
   if (isOptionFieldValue(value)) return optionOrderKey(value)
-  return `${typeof value}:${String(value)}`
+  return scalarOrderKey(value)
 }
 
 const completeListItemOrderKey = (value: CompleteListItem): string => {
   if (isUserFieldValue(value)) return userOrderKey(value)
   if (isOptionFieldValue(value)) return optionOrderKey(value)
-  return `${typeof value}:${String(value)}`
+  return scalarOrderKey(value)
 }
 
 const userOrderKey = (value: UserFieldValue): string =>
@@ -129,15 +131,12 @@ const userOrderKey = (value: UserFieldValue): string =>
 const optionOrderKey = (value: OptionFieldValue): string =>
   `option:${value.value.toLocaleLowerCase("en")}\u0000${value.id ?? ""}`
 
-const isCompleteListItem = (value: unknown): value is CompleteListItem => {
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return true
-    case "object":
-      return isUserFieldValue(value) || isOptionFieldValue(value)
-    default:
-      return false
-  }
+const scalarOrderKey = (value: string | number | boolean): string => {
+  const kind = Predicate.isString(value) ? "string" : Predicate.isNumber(value) ? "number" : "boolean"
+  return `${kind}:${String(value)}`
+}
+
+const isCompleteListItem = <UnparsedInput>(value: UnparsedInput): value is UnparsedInput & CompleteListItem => {
+  return Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value) ||
+    isUserFieldValue(value) || isOptionFieldValue(value)
 }

package/src/internal/sync/manifest.ts

@@ -21,7 +21,7 @@ export const parseSyncManifest = (
 ): Effect.Effect<SyncManifest, SyncWorkspaceError | SyncValidationError> =>
   Effect.gen(function*() {
     const raw = yield* Effect.try({
-      try: (): unknown => JSON.parse(content),
+      try: () => Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Json))(content),
       catch: (cause) => new SyncWorkspaceError({ message: "Failed to parse Sync Manifest JSON", path, cause })
     })
     return yield* Schema.decodeUnknownEffect(SyncManifestSchema)(raw).pipe(

package/src/internal/sync/schemas.ts

@@ -5,7 +5,7 @@
  */
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import { FIELD_SHAPES } from "./types.js"
+import { FIELD_CONTRACTS } from "./types.js"
 
 const SiteUrl = Schema.String.pipe(
   Schema.check(Schema.isPattern(/^https:\/\/[a-z0-9][a-z0-9-]*\.atlassian\.net$/))
@@ -14,14 +14,14 @@ const SiteUrl = Schema.String.pipe(
 const NonEmptyString = Schema.String.pipe(Schema.check(Schema.isMinLength(1)))
 const FilenameModes: readonly ["convention", "custom"] = ["convention", "custom"]
 
-export const FieldShapeSchema = Schema.Literals(FIELD_SHAPES)
+export const FieldContractSchema = Schema.Literals(FIELD_CONTRACTS)
 
 export const RequestedCustomFieldSchema = Schema.Struct({
   displayName: NonEmptyString,
   fieldId: Schema.optional(NonEmptyString),
-  shape: FieldShapeSchema,
+  form: FieldContractSchema,
   ordered: Schema.optional(Schema.Boolean)
-})
+}).pipe(Schema.encodeKeys({ form: "shape" }))
 
 export const WorkspaceConfigSchema = Schema.Struct({
   version: Schema.Literal(1).pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed(1))),
@@ -82,9 +82,9 @@ export const SyncFieldValueSchema = Schema.Union([
 export const BaselineCustomFieldSchema = Schema.Struct({
   fieldId: NonEmptyString,
   displayName: NonEmptyString,
-  shape: FieldShapeSchema,
+  form: FieldContractSchema,
   value: SyncFieldValueSchema
-})
+}).pipe(Schema.encodeKeys({ form: "shape" }))
 
 export const SyncBaselineSchema = Schema.Struct({
   version: Schema.Literal(1),

package/src/internal/sync/types.ts

@@ -4,7 +4,7 @@
  * @internal
  */
 
-export type FieldShape =
+export type FieldContract =
   | "text"
   | "multilineText"
   | "number"
@@ -15,7 +15,7 @@ export type FieldShape =
   | "user"
   | "cascadingSelect"
 
-export const FIELD_SHAPES: ReadonlyArray<FieldShape> = [
+export const FIELD_CONTRACTS: ReadonlyArray<FieldContract> = [
   "text",
   "multilineText",
   "number",
@@ -30,7 +30,7 @@ export const FIELD_SHAPES: ReadonlyArray<FieldShape> = [
 export interface RequestedCustomField {
   readonly displayName: string
   readonly fieldId?: string | undefined
-  readonly shape: FieldShape
+  readonly form: FieldContract
   readonly ordered?: boolean | undefined
 }
 
@@ -83,7 +83,7 @@ export type SyncFieldValue =
 export interface BaselineCustomField {
   readonly fieldId: string
   readonly displayName: string
-  readonly shape: FieldShape
+  readonly form: FieldContract
   readonly value: SyncFieldValue
 }
 

package/test/IssueService.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "@effect/vitest"
 import { JiraApiClient, make } from "@knpkv/jira-api-client"
 import * as Effect from "effect/Effect"
+import * as HttpClient from "effect/http/HttpClient"
+import * as HttpClientResponse from "effect/http/HttpClientResponse"
 import * as Layer from "effect/Layer"
 import * as Redacted from "effect/Redacted"
-import * as HttpClient from "effect/unstable/http/HttpClient"
-import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
 import { IssueService, layer as IssueServiceLayer, SiteUrl } from "../src/IssueService.js"
 
 const httpClient = HttpClient.make((request) =>