@knpkv/atlassian-common 0.4.0 → 1.1.0

package/src/attachments.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared attachment reference helpers for Atlassian Markdown surfaces.
+ *
+ * @module
+ */
+
+export interface AttachmentPreviewInput {
+  readonly id?: string | undefined
+  readonly filename: string
+  readonly url?: string | undefined
+  readonly mediaType?: string | null | undefined
+  readonly mimeType?: string | null | undefined
+  readonly size?: number | null | undefined
+}
+
+export interface AttachmentReferenceInput {
+  readonly id: string
+  readonly filename: string
+  readonly url: string
+  readonly mediaType: string | null
+  readonly size: number | null
+}
+
+export interface AttachmentPlaceholderReplacement {
+  readonly content: string
+  readonly replacements: number
+}
+
+export interface AttachmentPlaceholderMatch {
+  readonly label: string
+  readonly isImage: boolean
+}
+
+const IMAGE_EXTENSION_RE = /\.(avif|bmp|gif|jpe?g|png|svg|webp)$/i
+
+/**
+ * Returns true when an attachment should render as a Markdown image preview.
+ * SVG is previewable even when the remote API reports a generic content type.
+ */
+export const isPreviewableAttachment = (attachment: AttachmentPreviewInput): boolean => {
+  const type = attachment.mediaType ?? attachment.mimeType ?? ""
+  return type.toLowerCase().startsWith("image/") || IMAGE_EXTENSION_RE.test(attachment.filename)
+}
+
+export const normalizeAttachmentMediaType = (
+  mediaType: string | null | undefined,
+  mimeType?: string | null | undefined
+): string | null => {
+  const value = mediaType ?? mimeType
+  return value && value.trim().length > 0 ? value : null
+}
+
+export const renderAttachmentMarkdown = (
+  attachment: AttachmentReferenceInput,
+  options?: { readonly label?: string | null | undefined; readonly metadata?: string | null | undefined }
+): string => {
+  const label = escapeMarkdownLabel(options?.label?.trim() || attachment.filename)
+  const destination = safeMarkdownDestination(attachment.url)
+  const reference = isPreviewableAttachment(attachment)
+    ? `![${label}](${destination})`
+    : `[${label}](${destination})`
+  return options?.metadata ? `${options.metadata}\n${reference}` : reference
+}
+
+export const replaceAttachmentPlaceholder = (
+  content: string,
+  placeholderPath: string,
+  renderedAttachment: string | ((match: AttachmentPlaceholderMatch) => string),
+  options?: { readonly replaceAll?: boolean | undefined }
+): AttachmentPlaceholderReplacement => {
+  const escapedPath = escapeRegExp(placeholderPath)
+  const placeholder = new RegExp(`!?\\[([^\\]]*)\\]\\(${escapedPath}\\)`, "g")
+  let replacements = 0
+  const replaced = content.replace(placeholder, (match, label: string) => {
+    replacements++
+    return typeof renderedAttachment === "string"
+      ? renderedAttachment
+      : renderedAttachment({ isImage: match.startsWith("!"), label })
+  })
+  if (!options?.replaceAll && replacements > 1) {
+    return { content, replacements }
+  }
+  return { content: replaced, replacements }
+}
+
+const escapeMarkdownLabel = (value: string): string =>
+  value
+    .replace(/\\/g, "\\\\")
+    .replace(/\n+/g, " ")
+    .replace(/\[/g, "\\[")
+    .replace(/]/g, "\\]")
+
+const safeMarkdownDestination = (value: string): string =>
+  /[\s()<>]/.test(value)
+    ? `<${value.replace(/\n/g, "%0A").replace(/</g, "%3C").replace(/>/g, "%3E")}>`
+    : value
+
+const escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")

package/src/auth/OAuthEndpoints.ts

@@ -12,8 +12,10 @@
  *
  * @module
  */
+import * as Crypto from "effect/Crypto"
 import * as Effect from "effect/Effect"
 import * as Encoding from "effect/Encoding"
+import type * as PlatformError from "effect/PlatformError"
 
 /**
  * OAuth2 authorization endpoint.
@@ -59,6 +61,8 @@ export const CONFLUENCE_SCOPES = [
   "read:page:confluence",
   "write:page:confluence",
   "delete:page:confluence",
+  "read:attachment:confluence",
+  "write:attachment:confluence",
   "read:me",
   "offline_access"
 ]
@@ -120,23 +124,28 @@ export const buildAuthUrl = (options: BuildAuthUrlOptions): string => {
 
 /**
  * Generate a cryptographically random PKCE code verifier (RFC 7636).
- * Uses Web Crypto API (available in Node 18+, Deno, browsers).
+ * Uses Effect's platform Crypto service.
  *
  * @category PKCE
  */
-export const generateCodeVerifier = (): string => {
-  const bytes = new Uint8Array(32)
-  globalThis.crypto.getRandomValues(bytes)
-  return Encoding.encodeBase64Url(bytes)
-}
+export const generateCodeVerifier = (): Effect.Effect<string, PlatformError.PlatformError, Crypto.Crypto> =>
+  Effect.gen(function*() {
+    const cryptoService = yield* Crypto.Crypto
+    const bytes = yield* cryptoService.randomBytes(32)
+    return Encoding.encodeBase64Url(bytes)
+  })
 
 /**
  * Compute S256 code challenge from a code verifier (RFC 7636).
- * Uses Web Crypto `subtle.digest` — returns Effect since digest is async.
+ * Uses Effect's platform Crypto service.
  *
  * @category PKCE
  */
-export const computeCodeChallenge = (verifier: string): Effect.Effect<string> =>
-  Effect.promise(() => globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))).pipe(
-    Effect.map((hash) => Encoding.encodeBase64Url(new Uint8Array(hash)))
-  )
+export const computeCodeChallenge = (
+  verifier: string
+): Effect.Effect<string, PlatformError.PlatformError, Crypto.Crypto> =>
+  Effect.gen(function*() {
+    const cryptoService = yield* Crypto.Crypto
+    const hash = yield* cryptoService.digest("SHA-256", new TextEncoder().encode(verifier))
+    return Encoding.encodeBase64Url(hash)
+  })

package/src/auth/OAuthErrors.ts

@@ -16,6 +16,7 @@
  * @module
  */
 import * as Data from "effect/Data"
+import * as Predicate from "effect/Predicate"
 
 /**
  * OAuth flow step for error context.
@@ -48,12 +49,12 @@ export class OAuthError extends Data.TaggedError("OAuthError")<{
   readonly cause?: unknown
 }> {
   override get message(): string {
-    if (this.cause instanceof Error) {
-      return `OAuth ${this.step} failed: ${this.cause.message}`
-    }
     if (typeof this.cause === "string") {
       return `OAuth ${this.step} failed: ${this.cause}`
     }
+    if (Predicate.hasProperty(this.cause, "message")) {
+      return `OAuth ${this.step} failed: ${String(this.cause.message)}`
+    }
     return `OAuth ${this.step} failed`
   }
 }

package/src/auth/OAuthOperations.ts

@@ -18,6 +18,7 @@
  *
  * @module
  */
+import * as Clock from "effect/Clock"
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
@@ -199,12 +200,13 @@ export const refreshToken = (
     const tokenResponse = yield* Schema.decodeUnknownEffect(TokenResponseSchema)(body).pipe(
       Effect.mapError((cause) => new OAuthError({ step: "refresh", cause }))
     )
+    const nowMs = yield* Clock.currentTimeMillis
 
     return {
       ...token,
       access_token: tokenResponse.access_token,
       refresh_token: tokenResponse.refresh_token,
-      expires_at: Date.now() + tokenResponse.expires_in * 1000,
+      expires_at: nowMs + tokenResponse.expires_in * 1000,
       scope: tokenResponse.scope
     }
   })

package/src/auth/uuid.ts

@@ -1,14 +1,20 @@
 /**
- * Cryptographic UUID v4 generation via Web Crypto API.
+ * Cryptographic UUID v4 generation via Effect's platform Crypto service.
  *
  * @internal
  */
+import * as Crypto from "effect/Crypto"
 import * as Effect from "effect/Effect"
+import type * as PlatformError from "effect/PlatformError"
 
 /**
  * Generate a cryptographically secure UUID v4.
- * Uses Web Crypto API randomUUID (Node.js 19+, all modern browsers).
+ * Uses Effect's platform Crypto service.
  *
  * @category Utilities
  */
-export const generateUUID = (): Effect.Effect<string> => Effect.sync(() => globalThis.crypto.randomUUID())
+export const generateUUID = (): Effect.Effect<string, PlatformError.PlatformError, Crypto.Crypto> =>
+  Effect.gen(function*() {
+    const cryptoService = yield* Crypto.Crypto
+    return yield* cryptoService.randomUUIDv4
+  })

package/src/bin.ts

@@ -112,4 +112,4 @@ const program = Effect.gen(function*() {
   Effect.catch((error: unknown) => Console.error(String(error)).pipe(Effect.andThen(Effect.fail(error))))
 )
 
-NodeRuntime.runMain(program)
+NodeRuntime.runMain(program, { disableErrorReporting: true })

package/src/config/AuthProfiles.ts

@@ -73,7 +73,7 @@ const emptyProfiles = (): AuthProfilesFile => ({ profiles: [] })
 
 const parseJsonOrNull = (content: string): unknown | null => {
   try {
-    return JSON.parse(content) as unknown
+    return JSON.parse(content)
   } catch {
     return null
   }

package/src/config/ProfileManager.ts

@@ -12,7 +12,14 @@ import * as Schema from "effect/Schema"
 import type { HttpClient } from "effect/unstable/http"
 import type { OAuthError } from "../auth/OAuthErrors.js"
 import { refreshToken } from "../auth/OAuthOperations.js"
-import { type AuthProfile, findProfile, loadProfiles, saveProfiles, saveProfileToken } from "./AuthProfiles.js"
+import {
+  type AuthProfile,
+  type AuthProfilesFile,
+  findProfile,
+  loadProfiles,
+  saveProfiles,
+  saveProfileToken
+} from "./AuthProfiles.js"
 import { getProfilesPath, type HomeDirectoryError, HomeDirectoryTag } from "./ConfigPaths.js"
 import { type OAuthToken, OAuthTokenSchema } from "./OAuthSchemas.js"
 import { FileSystemError, isTokenExpired, loadOAuthConfig } from "./TokenStorage.js"
@@ -26,24 +33,24 @@ export interface AtlassianToolDefinition {
   readonly requiredScopes: ReadonlyArray<string>
 }
 
-export const JIRA_REQUIRED_SCOPES = [
+export const JIRA_REQUIRED_SCOPES: ReadonlyArray<string> = [
   "read:jira-work",
   "write:jira-work",
   "manage:jira-project",
   "read:jira-user",
   "read:me",
   "offline_access"
-] as const
+]
 
-export const CONFLUENCE_REQUIRED_SCOPES = [
+export const CONFLUENCE_REQUIRED_SCOPES: ReadonlyArray<string> = [
   "read:page:confluence",
   "write:page:confluence",
   "delete:page:confluence",
   "read:me",
   "offline_access"
-] as const
+]
 
-export const ATLASSIAN_TOOLS = [
+export const ATLASSIAN_TOOLS: ReadonlyArray<AtlassianToolDefinition> = [
   {
     toolName: "jira-cli",
     label: "Jira CLI",
@@ -64,7 +71,7 @@ export const ATLASSIAN_TOOLS = [
     loginHint: "jcf auth jira login",
     requiredScopes: JIRA_REQUIRED_SCOPES
   }
-] as const satisfies ReadonlyArray<AtlassianToolDefinition>
+]
 
 export type ProfileTokenStatus = "valid" | "expired"
 
@@ -97,6 +104,11 @@ export interface ToolProfileStatus {
 
 const authStoreName = (tool: AtlassianToolDefinition): string => tool.authStoreName ?? tool.toolName
 
+const toolStorePair = (
+  tool: AtlassianToolDefinition,
+  store: AuthProfilesFile
+): readonly [AtlassianToolDefinition, AuthProfilesFile] => [tool, store]
+
 const uniqueAuthTools = (tools: ReadonlyArray<AtlassianToolDefinition>): ReadonlyArray<AtlassianToolDefinition> =>
   tools.filter((tool, index) =>
     tools.findIndex((candidate) => authStoreName(candidate) === authStoreName(tool)) === index
@@ -122,7 +134,7 @@ const loadLegacyToken = (
       Effect.mapError((cause) => new FileSystemError({ operation: "read", path: authPath, cause }))
     )
     const parsed = yield* Effect.try({
-      try: () => JSON.parse(content) as unknown,
+      try: () => JSON.parse(content),
       catch: (cause) => cause
     }).pipe(Effect.catch(() => Effect.succeed(null)))
     if (parsed === null) return null
@@ -186,7 +198,7 @@ export const useProfileForAllTools = (
   Effect.gen(function*() {
     const authTools = uniqueAuthTools(tools)
     const stores = yield* Effect.forEach(authTools, (tool) =>
-      loadProfiles(authStoreName(tool)).pipe(Effect.map((store) => [tool, store] as const)))
+      loadProfiles(authStoreName(tool)).pipe(Effect.map((store) => toolStorePair(tool, store))))
     const selected = stores.map(([, store]) =>
       findProfile(store.profiles, selector)
     ).find((profile): profile is AuthProfile =>

package/src/config/TokenStorage.ts

@@ -29,7 +29,7 @@ import { type OAuthConfig, OAuthConfigSchema, type OAuthToken, OAuthTokenSchema
 
 const parseJsonOrNull = (content: string): unknown | null => {
   try {
-    return JSON.parse(content) as unknown
+    return JSON.parse(content)
   } catch {
     return null
   }

package/src/index.ts

@@ -32,3 +32,6 @@ export * from "./config/index.js"
 
 // Auth utilities
 export * from "./auth/index.js"
+
+// Attachment utilities
+export * from "./attachments.js"

package/src/serializers/MarkdownSerializer.ts

@@ -22,8 +22,10 @@
  * @module
  */
 import * as Effect from "effect/Effect"
+import type { BlockNode, BlockQuote, List } from "../ast/BlockNode.js"
 import type { Document, DocumentNode } from "../ast/Document.js"
 import type { InlineNode } from "../ast/InlineNode.js"
+import type { ExpandMacro, InfoPanel } from "../ast/MacroNode.js"
 import type { SerializeError } from "../SerializeError.js"
 
 /**
@@ -242,28 +244,18 @@ const serializeTable = (
     return lines.join("\n")
   })
 
-// Simple block type for list items - use unknown for flexibility
-type SimpleBlock = unknown
-
-// List item type
-type ListItemType = {
-  readonly _tag: "ListItem"
-  readonly checked?: boolean | undefined
-  readonly children: ReadonlyArray<unknown>
-}
-
 /**
  * Serialize list.
  */
 const serializeList = (
-  node: { ordered: boolean; start?: number | undefined; children: ReadonlyArray<unknown> },
+  node: List,
   options: SerializeOptions
 ): Effect.Effect<string, SerializeError> =>
   Effect.gen(function*() {
     const lines: Array<string> = []
     let counter = node.start ?? 1
 
-    for (const item of node.children as ReadonlyArray<ListItemType>) {
+    for (const item of node.children) {
       const prefix = node.ordered ? `${counter}.` : "-"
       const checkbox = item.checked !== undefined ? (item.checked ? "[x] " : "[ ] ") : ""
 
@@ -291,38 +283,31 @@ const serializeList = (
  * Serialize simple block (for nested content).
  */
 const serializeSimpleBlock = (
-  node: SimpleBlock,
+  node: BlockNode,
   options: SerializeOptions
 ): Effect.Effect<string, SerializeError> =>
   Effect.gen(function*() {
-    const tagged = node as { readonly _tag: string }
-    switch (tagged._tag) {
+    switch (node._tag) {
       case "Heading":
-        return yield* serializeHeading(
-          node as unknown as { level: 1 | 2 | 3 | 4 | 5 | 6; children: ReadonlyArray<InlineNode> }
-        )
+        return yield* serializeHeading(node)
       case "Paragraph":
-        return yield* serializeParagraph(node as unknown as { children: ReadonlyArray<InlineNode> })
+        return yield* serializeParagraph(node)
       case "CodeBlock":
-        return serializeCodeBlock(node as unknown as { code: string; language?: string | undefined })
+        return serializeCodeBlock(node)
       case "ThematicBreak":
         return "---"
       case "Image":
-        return serializeImage(
-          node as unknown as { src: string; alt?: string | undefined; title?: string | undefined },
-          options
-        )
+        return serializeImage(node, options)
       case "Table":
-        return yield* serializeTable(
-          node as unknown as {
-            header?: { cells: ReadonlyArray<{ children: ReadonlyArray<InlineNode> }> } | undefined
-            rows: ReadonlyArray<{ cells: ReadonlyArray<{ children: ReadonlyArray<InlineNode> }> }>
-          }
-        )
-      case "UnsupportedBlock": {
-        const unsupported = node as unknown as { rawMarkdown?: string; rawHtml?: string; rawAdf?: string }
-        return unsupported.rawMarkdown ?? unsupported.rawHtml ?? unsupported.rawAdf ?? ""
-      }
+        return yield* serializeTable(node)
+      case "List":
+        return yield* serializeList(node, options)
+      case "BlockQuote":
+        return yield* serializeBlockQuote(node, options)
+      case "TaskList":
+        return yield* serializeTaskList(node.children, options)
+      case "UnsupportedBlock":
+        return node.rawMarkdown ?? node.rawHtml ?? node.rawAdf ?? ""
       default:
         return ""
     }
@@ -332,7 +317,7 @@ const serializeSimpleBlock = (
  * Serialize block quote.
  */
 const serializeBlockQuote = (
-  node: { children: ReadonlyArray<unknown> },
+  node: BlockQuote,
   options: SerializeOptions
 ): Effect.Effect<string, SerializeError> =>
   Effect.gen(function*() {
@@ -349,7 +334,7 @@ const serializeBlockQuote = (
  * Serialize info panel to container syntax.
  */
 const serializeInfoPanel = (
-  node: { panelType: string; title?: string | undefined; children: ReadonlyArray<unknown> },
+  node: InfoPanel,
   options: SerializeOptions
 ): Effect.Effect<string, SerializeError> =>
   Effect.gen(function*() {
@@ -370,7 +355,7 @@ const serializeInfoPanel = (
  * Serialize expand macro.
  */
 const serializeExpandMacro = (
-  node: { title?: string | undefined; children: ReadonlyArray<unknown> },
+  node: ExpandMacro,
   options: SerializeOptions
 ): Effect.Effect<string, SerializeError> =>
   Effect.gen(function*() {

package/test/AuthProfiles.test.ts

@@ -57,7 +57,7 @@ const makeMockFS = (files: Record<string, string> = {}) => {
 
   return {
     store,
-    layer: Layer.succeed(FileSystem.FileSystem, FileSystem.FileSystem.of(partial as FileSystem.FileSystem))
+    layer: Layer.succeed(FileSystem.FileSystem, FileSystem.FileSystem.of(partial))
   }
 }
 

package/test/OAuthEndpoints.test.ts

@@ -1,25 +1,43 @@
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto"
 import { it as effectIt } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import { describe, expect, it } from "vitest"
-import { AUTH_URL, buildAuthUrl, computeCodeChallenge, generateCodeVerifier } from "../src/auth/OAuthEndpoints.js"
+import {
+  AUTH_URL,
+  buildAuthUrl,
+  computeCodeChallenge,
+  CONFLUENCE_SCOPES,
+  generateCodeVerifier
+} from "../src/auth/OAuthEndpoints.js"
+
+const withCrypto = <A, E, R>(effect: Effect.Effect<A, E, R>) => effect.pipe(Effect.provide(NodeCrypto.layer))
 
 describe("OAuthEndpoints", () => {
+  describe("CONFLUENCE_SCOPES", () => {
+    it("includes attachment read and write scopes", () => {
+      expect(CONFLUENCE_SCOPES).toContain("read:attachment:confluence")
+      expect(CONFLUENCE_SCOPES).toContain("write:attachment:confluence")
+    })
+  })
+
   // ---- PKCE ----
 
   describe("generateCodeVerifier", () => {
     // 32 random bytes base64url-encoded = 43 chars; verifies output shape for RFC 7636 compliance
-    it("returns a base64url string of 43 characters (32 random bytes)", () => {
-      const verifier = generateCodeVerifier()
-      expect(verifier).toHaveLength(43)
-      expect(verifier).toMatch(/^[A-Za-z0-9_-]+$/)
-    })
+    effectIt.effect("returns a base64url string of 43 characters (32 random bytes)", () =>
+      Effect.gen(function*() {
+        const verifier = yield* generateCodeVerifier()
+        expect(verifier).toHaveLength(43)
+        expect(verifier).toMatch(/^[A-Za-z0-9_-]+$/)
+      }).pipe(withCrypto))
 
     // PKCE verifiers must be unique per auth request — reuse enables replay attacks
-    it("produces unique values", () => {
-      const a = generateCodeVerifier()
-      const b = generateCodeVerifier()
-      expect(a).not.toBe(b)
-    })
+    effectIt.effect("produces unique values", () =>
+      Effect.gen(function*() {
+        const a = yield* generateCodeVerifier()
+        const b = yield* generateCodeVerifier()
+        expect(a).not.toBe(b)
+      }).pipe(withCrypto))
   })
 
   describe("computeCodeChallenge", () => {
@@ -30,23 +48,23 @@ describe("OAuthEndpoints", () => {
         const expected = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"
         const challenge = yield* computeCodeChallenge(verifier)
         expect(challenge).toBe(expected)
-      }))
+      }).pipe(withCrypto))
 
     // Same verifier must always produce same challenge — server verifies this on token exchange
     effectIt.effect("is deterministic", () =>
       Effect.gen(function*() {
-        const v = generateCodeVerifier()
+        const v = yield* generateCodeVerifier()
         const a = yield* computeCodeChallenge(v)
         const b = yield* computeCodeChallenge(v)
         expect(a).toBe(b)
-      }))
+      }).pipe(withCrypto))
 
     // base64url must not contain +, /, = — these break URL query params
     effectIt.effect("produces base64url output (no +, /, =)", () =>
       Effect.gen(function*() {
         const challenge = yield* computeCodeChallenge("test-verifier-string")
         expect(challenge).toMatch(/^[A-Za-z0-9_-]+$/)
-      }))
+      }).pipe(withCrypto))
   })
 
   // ---- buildAuthUrl ----
@@ -103,7 +121,7 @@ describe("OAuthEndpoints", () => {
           const parsed = new URL(url)
           expect(parsed.searchParams.get("code_challenge")).toBe(challenge)
           expect(parsed.searchParams.get("code_challenge_method")).toBe("S256")
-        })
+        }).pipe(withCrypto)
     )
   })
 })

package/test/OAuthOperations.test.ts

@@ -1,6 +1,7 @@
 import { describe, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import { TestClock } from "effect/testing"
 import type { HttpClientRequest } from "effect/unstable/http"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { expect } from "vitest"
@@ -58,6 +59,8 @@ const oauthConfig: OAuthConfig = {
   clientSecret: "csecret"
 }
 
+const TEST_NOW = Date.parse("2026-01-01T00:00:00.000Z")
+
 const oauthToken: OAuthToken = {
   access_token: "old-access",
   refresh_token: "old-refresh",
@@ -221,6 +224,7 @@ describe("OAuthOperations", () => {
     // Verifies grant_type=refresh_token is sent and returned token preserves cloud_id/site_url from original
     it.effect("sends refresh_token and returns updated OAuthToken", () =>
       Effect.gen(function*() {
+        yield* TestClock.setTime(TEST_NOW)
         const { capturedRequests, mockClient } = createMockHttpClient([
           { status: 200, body: { ...validTokenBody, access_token: "new-access", refresh_token: "new-refresh" } }
         ])
@@ -232,7 +236,7 @@ describe("OAuthOperations", () => {
         // preserves existing fields
         expect(result.cloud_id).toBe("cloud-1")
         expect(result.site_url).toBe("https://site.atlassian.net")
-        expect(result.expires_at).toBeGreaterThan(Date.now())
+        expect(result.expires_at).toBe(TEST_NOW + validTokenBody.expires_in * 1000)
 
         const req = capturedRequests[0]!
         const body = yield* req.body._tag === "Uint8Array"

package/test/ProfileManager.test.ts

@@ -64,7 +64,7 @@ const makeMockFS = () => {
   }
   return {
     store,
-    layer: Layer.succeed(FileSystem.FileSystem, FileSystem.FileSystem.of(partial as FileSystem.FileSystem))
+    layer: Layer.succeed(FileSystem.FileSystem, FileSystem.FileSystem.of(partial))
   }
 }