okengine 0.2.6 → 0.2.8

package/src/docker/stack-id.ts

@@ -1,13 +1,14 @@
 /**
  * Per-project local stack identity — unique compose project + host ports.
  *
- * `oke dev --stack` must not share one `oke-dev` Postgres across every app on
+ * `oke dev --docker` must not share one `oke-dev` Postgres across every app on
  * the machine. Identity is a stable short hash of the project cwd.
  */
 
 import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import type { ServiceCredentials } from "./types.ts";
+import { DEFAULT_DOCKER_DIR } from "./types.ts";
 import { defaultHostPort, envPrefix } from "./helpers.ts";
 
 /**
@@ -16,10 +17,7 @@ import { defaultHostPort, envPrefix } from "./helpers.ts";
  * @param cwd - Project root
  */
 export function stackInstanceId(cwd: string): string {
-  return createHash("sha256")
-    .update(resolve(cwd))
-    .digest("hex")
-    .slice(0, 6);
+  return createHash("sha256").update(resolve(cwd)).digest("hex").slice(0, 6);
 }
 
 /**
@@ -31,6 +29,15 @@ export function stackAppSlug(cwd: string): string {
   return `dev-${stackInstanceId(cwd)}`;
 }
 
+/**
+ * Stable 0–999 offset derived from a stack instance id.
+ *
+ * @param instanceId - 6-hex stack id
+ */
+export function instancePortOffset(instanceId: string): number {
+  return Number.parseInt(instanceId.slice(0, 4), 16) % 1000;
+}
+
 /**
  * Host port for a role, offset by instance id so two stacks can run at once.
  *
@@ -43,7 +50,7 @@ export function hostPortForInstance(
   containerPort: number,
   instanceId: string,
 ): number {
-  const n = Number.parseInt(instanceId.slice(0, 4), 16) % 1000;
+  const n = instancePortOffset(instanceId);
   if (role === "store.sql") return 15_000 + n;
   if (role === "store.kv") return 16_000 + n;
   if (role === "signal") return 17_000 + n;
@@ -51,7 +58,7 @@ export function hostPortForInstance(
 }
 
 /**
- * Parse role credentials from an existing `.env.stack` body (reuse on restart).
+ * Parse role credentials from an existing `.env.docker` body (reuse on restart).
  *
  * @param text - Dotenv contents
  * @param roles - Roles to look up
@@ -91,7 +98,9 @@ export function parseStackCredentials(
 }
 
 /**
- * Load credentials from project `.env.stack` when present.
+ * Load credentials from `docker/.env.docker` when present.
+ *
+ * Soft-compat: also reads legacy project-root `.env.docker`.
  *
  * @param cwd - Project root
  * @param roles - Image roles
@@ -100,9 +109,12 @@ export async function loadExistingStackCredentials(
   cwd: string,
   roles: readonly string[],
 ): Promise<Readonly<Record<string, ServiceCredentials>> | undefined> {
-  const path = resolve(cwd, ".env.stack");
-  const file = Bun.file(path);
-  if (!(await file.exists())) return undefined;
-  const parsed = parseStackCredentials(await file.text(), roles);
-  return Object.keys(parsed).length > 0 ? parsed : undefined;
+  const candidates = [resolve(cwd, DEFAULT_DOCKER_DIR, ".env.docker"), resolve(cwd, ".env.docker")];
+  for (const path of candidates) {
+    const file = Bun.file(path);
+    if (!(await file.exists())) continue;
+    const parsed = parseStackCredentials(await file.text(), roles);
+    if (Object.keys(parsed).length > 0) return parsed;
+  }
+  return undefined;
 }

package/src/docker/stack.integration.test.ts

@@ -6,11 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  deriveInfrastructure,
-  formatStackEnv,
-  writeDerivedFiles,
-} from "./index.ts";
+import { deriveInfrastructure, formatStackEnv, writeDerivedFiles } from "./index.ts";
 
 async function dockerAvailable(): Promise<boolean> {
   try {
@@ -24,7 +20,7 @@ async function dockerAvailable(): Promise<boolean> {
   }
 }
 
-describe("oke dev --stack postgres integration", () => {
+describe("oke dev --docker postgres integration", () => {
   test("compose brings up postgres and the app talks to it", async () => {
     if (!(await dockerAvailable())) {
       console.warn("skipping: docker daemon not available");
@@ -51,21 +47,12 @@ describe("oke dev --stack postgres integration", () => {
       });
       await writeDerivedFiles(derived, dockerDir, {
         writeStackEnv: true,
-        stackEnvDir: dir,
       });
 
       // Infra-only: network + role compose (no app build).
       const composeFiles = ["compose.yml", "compose.store.sql.yml"];
       const up = Bun.spawn(
-        [
-          "docker",
-          "compose",
-          "-p",
-          project,
-          ...composeFiles.flatMap((f) => ["-f", f]),
-          "up",
-          "-d",
-        ],
+        ["docker", "compose", "-p", project, ...composeFiles.flatMap((f) => ["-f", f]), "up", "-d"],
         {
           cwd: dockerDir,
           stdout: "pipe",
@@ -120,13 +107,11 @@ describe("oke dev --stack postgres integration", () => {
         await sql.close();
       }
 
-      // Prove credentials live in .env.stack, not YAML.
+      // Prove credentials live in docker/.env.docker, not YAML.
       const yml = await Bun.file(join(dockerDir, "compose.store.sql.yml")).text();
       expect(yml).not.toContain("stack-integration-pass");
-      expect(formatStackEnv(derived.stackEnv)).toContain(
-        "stack-integration-pass",
-      );
-      expect(await Bun.file(join(dir, ".env.stack")).exists()).toBe(true);
+      expect(formatStackEnv(derived.stackEnv)).toContain("stack-integration-pass");
+      expect(await Bun.file(join(dockerDir, ".env.docker")).exists()).toBe(true);
     } finally {
       await Bun.spawn(
         [

package/src/docker/types.ts

@@ -37,7 +37,7 @@ export interface ServiceSpec {
   readonly port: number;
   /** Host port published in compose (dev defaults). */
   readonly hostPort: number;
-  /** Credential placeholders (values live in `.env.stack`, not YAML). */
+  /** Credential placeholders (values live in `.env.docker`, not YAML). */
   readonly credentials: ServiceCredentials;
 }
 
@@ -50,6 +50,12 @@ export interface ComposeHealthcheck {
   readonly start_period?: string;
 }
 
+/** Extra published host↔container port pair from a recipe. */
+export interface RecipeExtraPort {
+  readonly host: number;
+  readonly container: number;
+}
+
 /** Image-specific compose fragment from {@link ImageRecipe.apply}. */
 export interface RecipeApplyResult {
   readonly environment?: Readonly<Record<string, string>>;
@@ -57,6 +63,8 @@ export interface RecipeApplyResult {
   readonly healthcheck?: ComposeHealthcheck;
   readonly volumes?: readonly string[];
   readonly user?: string;
+  /** Additional published ports (e.g. Mailpit UI, RustFS console). */
+  readonly extraPorts?: readonly RecipeExtraPort[];
 }
 
 /**
@@ -102,12 +110,13 @@ export interface DeriveOptions {
   readonly prod?: boolean;
   /**
    * Include the `app` service in `compose.yml` (default true).
-   * `oke dev --stack` sets false — host Bun runs the app; Docker is infra only.
+   * `oke dev --docker` sets false — host Bun runs the app; Docker is infra only.
    */
   readonly includeApp?: boolean;
   /**
    * Compose artefact directory relative to the project root (default `docker`).
-   * Controls generated `env_file` / `build.context` paths (e.g. `../.env.stack`).
+   * Controls generated `env_file` / `build.context` paths (`.env.docker` lives
+   * beside compose under this directory).
    * Pass `"."` for legacy root-level layout.
    */
   readonly composeDir?: string;
@@ -144,7 +153,7 @@ export interface DeriveResult {
   /** Generated files (Dockerfile + compose layers). */
   readonly files: readonly GeneratedFile[];
   /**
-   * Stack env contents for `.env.stack` — written by `oke dev --stack`,
+   * Stack env contents for `.env.docker` — written by `oke dev --docker`,
    * never embedded in YAML.
    */
   readonly stackEnv: Readonly<Record<string, string>>;

package/src/drivers/ai-anthropic.ts

@@ -21,9 +21,7 @@ const ANTHROPIC_VERSION = "2023-06-01";
  *
  * @param options - API key / model / base URL / injectable fetch
  */
-export async function openAnthropic(
-  options: AiOpenOptions = {},
-): Promise<AiModelClient> {
+export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiModelClient> {
   const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
     throw new Error("anthropic: apiKey is required (or ANTHROPIC_API_KEY)");
@@ -48,17 +46,14 @@ export async function openAnthropic(
         body: JSON.stringify({
           model: resolvedModel,
           max_tokens: opts.maxTokens ?? 1024,
-          ...(opts.temperature !== undefined
-            ? { temperature: opts.temperature }
-            : {}),
+          ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
           ...(system !== undefined ? { system } : {}),
           messages,
         }),
       });
       const raw = (await res.json().catch(() => ({}))) as AnthropicMessagesResponse;
       if (!res.ok) {
-        const msg =
-          raw.error?.message ?? `anthropic HTTP ${res.status}`;
+        const msg = raw.error?.message ?? `anthropic HTTP ${res.status}`;
         throw new Error(`anthropic: ${msg}`);
       }
       const text = textFromContent(raw.content);
@@ -92,9 +87,7 @@ interface AnthropicMessagesResponse {
   readonly error?: { readonly message?: string };
 }
 
-function splitSystem(
-  messages: AiCompleteOptions["messages"],
-): {
+function splitSystem(messages: AiCompleteOptions["messages"]): {
   system?: string;
   messages: Array<{ role: "user" | "assistant"; content: string }>;
 } {
@@ -117,9 +110,7 @@ function splitSystem(
   };
 }
 
-function textFromContent(
-  content: AnthropicMessagesResponse["content"],
-): string {
+function textFromContent(content: AnthropicMessagesResponse["content"]): string {
   if (!content?.length) return "";
   return content
     .filter((b) => b.type === "text" && typeof b.text === "string")

package/src/drivers/ai-mock.ts

@@ -39,8 +39,7 @@ export const mockAiDriver: AiDriver = {
         if (payload === undefined) {
           payload = canned["*"] ?? { ok: true, echo: last };
         }
-        const text =
-          typeof payload === "string" ? payload : JSON.stringify(payload);
+        const text = typeof payload === "string" ? payload : JSON.stringify(payload);
         return {
           text,
           raw: payload,
@@ -70,9 +69,7 @@ export const mockAiDriver: AiDriver = {
  *
  * @param responses - Key → JSON payload
  */
-export function createMockAiDriver(
-  responses: Readonly<Record<string, unknown>>,
-): AiDriver {
+export function createMockAiDriver(responses: Readonly<Record<string, unknown>>): AiDriver {
   return {
     id: "mock",
     open(options = {}) {

package/src/drivers/ai-openai-compatible.ts

@@ -23,14 +23,10 @@ const DEFAULT_BASE = "https://api.openai.com/v1";
  *
  * @param options - API key / model / base URL / injectable fetch
  */
-export async function openOpenaiCompatible(
-  options: AiOpenOptions = {},
-): Promise<AiModelClient> {
+export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise<AiModelClient> {
   const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
   if (!apiKey) {
-    throw new Error(
-      "openai-compatible: apiKey is required (or OPENAI_API_KEY)",
-    );
+    throw new Error("openai-compatible: apiKey is required (or OPENAI_API_KEY)");
   }
   const model = options.model ?? "gpt-4o-mini";
   const baseUrl = (options.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
@@ -65,8 +61,7 @@ export async function openOpenaiCompatible(
       });
       const raw = (await res.json().catch(() => ({}))) as OpenAiChatResponse;
       if (!res.ok) {
-        const msg =
-          raw.error?.message ?? `openai-compatible HTTP ${res.status}`;
+        const msg = raw.error?.message ?? `openai-compatible HTTP ${res.status}`;
         throw new Error(`openai-compatible: ${msg}`);
       }
       const text = raw.choices?.[0]?.message?.content ?? "";
@@ -94,8 +89,7 @@ export async function openOpenaiCompatible(
       });
       const raw = (await res.json().catch(() => ({}))) as OpenAiEmbedResponse;
       if (!res.ok) {
-        const msg =
-          raw.error?.message ?? `openai-compatible embed HTTP ${res.status}`;
+        const msg = raw.error?.message ?? `openai-compatible embed HTTP ${res.status}`;
         throw new Error(`openai-compatible: ${msg}`);
       }
       const vectors = (raw.data ?? [])

package/src/drivers/ai-providers.test.ts

@@ -4,10 +4,7 @@
 
 import { describe, expect, test } from "bun:test";
 import { anthropicAiDriver, openAnthropic } from "./ai-anthropic.ts";
-import {
-  openaiCompatibleAiDriver,
-  openOpenaiCompatible,
-} from "./ai-openai-compatible.ts";
+import { openaiCompatibleAiDriver, openOpenaiCompatible } from "./ai-openai-compatible.ts";
 import { mockAiDriver } from "./ai-mock.ts";
 
 describe("anthropic driver", () => {
@@ -56,9 +53,7 @@ describe("anthropic driver", () => {
       messages: Array<{ role: string }>;
     };
     expect(body.system).toBe("be brief");
-    expect(body.messages).toEqual([
-      { role: "user", content: "hi" } as { role: string },
-    ]);
+    expect(body.messages).toEqual([{ role: "user", content: "hi" } as { role: string }]);
   });
 
   test("HTTP error surfaces provider message", async () => {
@@ -73,18 +68,16 @@ describe("anthropic driver", () => {
       apiKey: "sk-test",
       fetch: fetchFn,
     });
-    await expect(
-      client.complete({ messages: [{ role: "user", content: "x" }] }),
-    ).rejects.toThrow("rate limited");
+    await expect(client.complete({ messages: [{ role: "user", content: "x" }] })).rejects.toThrow(
+      "rate limited",
+    );
   });
 
   test("live Anthropic ask when ANTHROPIC_API_KEY is set", async () => {
     const key = process.env.ANTHROPIC_API_KEY;
     if (!key) {
       // Clearly-marked skip — never fail CI for lack of credentials.
-      console.log(
-        "skip: live anthropic ask (ANTHROPIC_API_KEY not set)",
-      );
+      console.log("skip: live anthropic ask (ANTHROPIC_API_KEY not set)");
       return;
     }
     const client = await anthropicAiDriver.open({

package/src/drivers/bun-native-completeness.test.ts

@@ -7,10 +7,7 @@
 
 import { describe, expect, test } from "bun:test";
 import { createBunRedisClient } from "./redis.ts";
-import {
-  createBunSignalRedisClient,
-  parseXreadgroupReply,
-} from "./signal-redis.ts";
+import { createBunSignalRedisClient, parseXreadgroupReply } from "./signal-redis.ts";
 
 /** One row in the completeness report. */
 export interface BunNativeGapRow {
@@ -26,10 +23,7 @@ export interface BunNativeGapRow {
  * Kept as a pure function so the gate test and human report share one source.
  */
 export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
-  const redisProto = Bun.RedisClient.prototype as unknown as Record<
-    string,
-    unknown
-  >;
+  const redisProto = Bun.RedisClient.prototype as unknown as Record<string, unknown>;
   const hasTypedScan = typeof redisProto.scan === "function";
   const hasTypedPublish = typeof redisProto.publish === "function";
   const hasTypedSubscribe = typeof redisProto.subscribe === "function";
@@ -57,8 +51,7 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
     {
       surface: "redis signal",
       capability: "native Bun bind (publish/subscribe)",
-      status:
-        hasTypedPublish && hasTypedSubscribe ? "closed" : "bun_limitation",
+      status: hasTypedPublish && hasTypedSubscribe ? "closed" : "bun_limitation",
       note:
         hasTypedPublish && hasTypedSubscribe
           ? "createBunSignalRedisClient uses typed publish/subscribe"
@@ -107,9 +100,7 @@ describe("Bun native client completeness", () => {
     expect(rows.length).toBe(8);
 
     const closed = rows.filter((r) => r.status === "closed").map((r) => r.capability);
-    const limited = rows
-      .filter((r) => r.status === "bun_limitation")
-      .map((r) => r.capability);
+    const limited = rows.filter((r) => r.status === "bun_limitation").map((r) => r.capability);
 
     // Closed on Bun 1.3.14
     expect(closed).toContain("SCAN (typed)");
@@ -141,13 +132,13 @@ describe("Bun native client completeness", () => {
       [
         "oke:signal:order",
         [
-          ["1-0", ["payload", "{\"a\":1}", "signal", "order"]],
+          ["1-0", ["payload", '{"a":1}', "signal", "order"]],
           ["1-1", ["payload", "{}", "signal", "order"]],
         ],
       ],
     ]);
     expect(parsed).toEqual([
-      { id: "1-0", fields: { payload: "{\"a\":1}", signal: "order" } },
+      { id: "1-0", fields: { payload: '{"a":1}', signal: "order" } },
       { id: "1-1", fields: { payload: "{}", signal: "order" } },
     ]);
     expect(parseXreadgroupReply(null)).toEqual([]);

package/src/drivers/channel-console.ts

@@ -21,9 +21,7 @@ import { createChannelInbox } from "./channel-types.ts";
 function formatAddressInput(input: AddressInput): string {
   if (typeof input === "string") return input;
   if (Array.isArray(input)) {
-    return input
-      .map((t) => (typeof t === "string" ? t : t.address))
-      .join(",");
+    return input.map((t) => (typeof t === "string" ? t : t.address)).join(",");
   }
   return input.address;
 }
@@ -33,9 +31,7 @@ function formatAddressInput(input: AddressInput): string {
  *
  * @param options - Optional shared inbox
  */
-export function openConsoleChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openConsoleChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   const inbox = options.inbox ?? createChannelInbox();
 
   const channel: ChannelTransport = {
@@ -88,7 +84,10 @@ export function openConsoleChannel(
         template: mail.template,
         at: Date.now(),
       });
-      const recipients = to.split(",").map((s) => s.trim()).filter(Boolean);
+      const recipients = to
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
       return {
         messageId: id,
         accepted: recipients,

package/src/drivers/channel-fcm.ts

@@ -15,9 +15,7 @@ import type {
  *
  * @param options - `token` (OAuth access token) + `from` (project id)
  */
-export function openFcmChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openFcmChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   const accessToken = options.token ?? options.apiKey;
   const projectId = options.from;
   const fetchFn = options.fetch ?? globalThis.fetch;
@@ -30,31 +28,25 @@ export function openFcmChannel(
       if (!accessToken || !projectId) {
         throw new Error("fcm: token and from (project id) are required");
       }
-      const res = await fetchFn(
-        `${base}/v1/projects/${projectId}/messages:send`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            message: {
-              token: message.to,
-              notification: {
-                title: message.subject ?? message.template ?? "notification",
-                body: message.text ?? "",
-              },
-              data: Object.fromEntries(
-                Object.entries(message.data ?? {}).map(([k, v]) => [
-                  k,
-                  String(v),
-                ]),
-              ),
-            },
-          }),
+      const res = await fetchFn(`${base}/v1/projects/${projectId}/messages:send`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
         },
-      );
+        body: JSON.stringify({
+          message: {
+            token: message.to,
+            notification: {
+              title: message.subject ?? message.template ?? "notification",
+              body: message.text ?? "",
+            },
+            data: Object.fromEntries(
+              Object.entries(message.data ?? {}).map(([k, v]) => [k, String(v)]),
+            ),
+          },
+        }),
+      });
       const body = (await res.json().catch(() => ({}))) as {
         name?: string;
         error?: { message?: string };
@@ -79,9 +71,7 @@ export function openFcmChannel(
         ok: true,
         messageId: id,
         driverId: "fcm",
-        attempts: [
-          { driverId: "fcm", ok: true, at: Date.now(), messageId: id },
-        ],
+        attempts: [{ driverId: "fcm", ok: true, at: Date.now(), messageId: id }],
       };
     },
   };

package/src/drivers/channel-resend.ts

@@ -10,9 +10,7 @@ import type { ChannelDriver, ChannelOpenOptions } from "./channel-types.ts";
  *
  * @param options - API key
  */
-export function openResendChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openResendChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   if (!options.apiKey) {
     throw new Error("resend channel: apiKey is required");
   }

package/src/drivers/channel-smtp.ts

@@ -10,18 +10,14 @@ import type { ChannelDriver, ChannelOpenOptions } from "./channel-types.ts";
  *
  * @param options - Host / port / auth
  */
-export function openSmtpChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openSmtpChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   if (!options.host) {
     throw new Error("smtp channel: host is required");
   }
   const transport = new SMTPTransport({
     host: options.host,
     port: options.port ?? 587,
-    ...(options.user && options.pass
-      ? { auth: { user: options.user, pass: options.pass } }
-      : {}),
+    ...(options.user && options.pass ? { auth: { user: options.user, pass: options.pass } } : {}),
   });
   return { id: "smtp", transport };
 }

package/src/drivers/channel-types.ts

@@ -5,12 +5,7 @@
  * run unchanged. Non-email media (sms / whatsapp / push) use {@link ChannelTransport}.
  */
 
-import type {
-  MailOptions,
-  SendResult,
-  Transport,
-  VerifyResult,
-} from "sently";
+import type { MailOptions, SendResult, Transport, VerifyResult } from "sently";
 
 export type {
   Address,
@@ -35,12 +30,7 @@ export type ChannelDriverId =
   | "webpush";
 
 /** Channel medium. */
-export type ChannelMediumId =
-  | "email"
-  | "sms"
-  | "whatsapp"
-  | "push"
-  | "any";
+export type ChannelMediumId = "email" | "sms" | "whatsapp" | "push" | "any";
 
 /** Unified outbound message (medium-agnostic). */
 export interface ChannelMessage {

package/src/drivers/channel-unifonic.ts

@@ -15,9 +15,7 @@ import type {
  *
  * @param options - `apiKey` + optional `from` (sender id)
  */
-export function openUnifonicChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openUnifonicChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   const apiKey = options.apiKey;
   const from = options.from ?? "OKE";
   const fetchFn = options.fetch ?? globalThis.fetch;
@@ -62,9 +60,7 @@ export function openUnifonicChannel(
         ok: true,
         messageId: id,
         driverId: "unifonic",
-        attempts: [
-          { driverId: "unifonic", ok: true, at: Date.now(), messageId: id },
-        ],
+        attempts: [{ driverId: "unifonic", ok: true, at: Date.now(), messageId: id }],
       };
     },
   };

package/src/drivers/channel-wa-cloud.ts

@@ -15,9 +15,7 @@ import type {
  *
  * @param options - `token` (access token) + `from` (phone number id)
  */
-export function openWaCloudChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openWaCloudChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   const token = options.token ?? options.apiKey;
   const phoneNumberId = options.from;
   const fetchFn = options.fetch ?? globalThis.fetch;
@@ -67,9 +65,7 @@ export function openWaCloudChannel(
         ok: true,
         messageId: id,
         driverId: "wa-cloud",
-        attempts: [
-          { driverId: "wa-cloud", ok: true, at: Date.now(), messageId: id },
-        ],
+        attempts: [{ driverId: "wa-cloud", ok: true, at: Date.now(), messageId: id }],
       };
     },
   };