Switch to double quotes and reformat codebase with Biome

packages/app/src/desktop/daemon/desktop-daemon-transport.test.ts

@@ -1,23 +1,31 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
 
 const desktopDaemonMock = vi.hoisted(() => {
-  let eventHandler: ((payload: {
-    sessionId: string;
-    kind: "open" | "message" | "close" | "error";
-    text?: string | null;
-    binaryBase64?: string | null;
-    code?: number | null;
-    reason?: string | null;
-    error?: string | null;
-  }) => void) | null = null;
+  let eventHandler:
+    | ((payload: {
+        sessionId: string;
+        kind: "open" | "message" | "close" | "error";
+        text?: string | null;
+        binaryBase64?: string | null;
+        code?: number | null;
+        reason?: string | null;
+        error?: string | null;
+      }) => void)
+    | null = null;
 
   const openLocalTransportSession = vi.fn<(...args: unknown[]) => Promise<string>>();
-  const listenToLocalTransportEvents = vi.fn(async (handler: typeof eventHandler extends ((...args: infer A) => any) | null ? (...args: A) => void : never) => {
-    eventHandler = handler;
-    return () => {
-      eventHandler = null;
-    };
-  });
+  const listenToLocalTransportEvents = vi.fn(
+    async (
+      handler: typeof eventHandler extends ((...args: infer A) => any) | null
+        ? (...args: A) => void
+        : never,
+    ) => {
+      eventHandler = handler;
+      return () => {
+        eventHandler = null;
+      };
+    },
+  );
   const sendLocalTransportMessage = vi.fn(async () => undefined);
   const closeLocalTransportSession = vi.fn(async () => undefined);
 
@@ -61,7 +69,7 @@ describe("desktop-daemon-transport", () => {
       () =>
         new Promise<string>((resolve) => {
           resolveSession = resolve;
-        })
+        }),
     );
 
     const mod = await import("./desktop-daemon-transport");
@@ -97,13 +105,13 @@ describe("desktop-daemon-transport", () => {
       () =>
         new Promise<string>((resolve) => {
           resolveSession = resolve;
-        })
+        }),
     );
     desktopDaemonMock.listenToLocalTransportEvents.mockImplementation(
       () =>
         new Promise<() => void>((resolve) => {
           resolveListen = resolve;
-        })
+        }),
     );
 
     const mod = await import("./desktop-daemon-transport");

packages/app/src/desktop/daemon/desktop-daemon-transport.ts

@@ -142,15 +142,15 @@ export function createDesktopLocalDaemonTransportFactory(): DaemonTransportFacto
         }
         if (typeof data === "string") {
           void sendLocalTransportMessage({ sessionId, text: data }).catch((error) =>
-            emitError(error)
+            emitError(error),
           );
           return;
         }
         const binaryBase64 = encodeBinaryToBase64(
-          data instanceof ArrayBuffer ? data : new Uint8Array(data)
+          data instanceof ArrayBuffer ? data : new Uint8Array(data),
         );
         void sendLocalTransportMessage({ sessionId, binaryBase64 }).catch((error) =>
-          emitError(error)
+          emitError(error),
         );
       },
       close: () => {

packages/app/src/desktop/daemon/desktop-daemon.ts

@@ -1,214 +1,214 @@
-import { getDesktopHost, isDesktop } from '@/desktop/host'
-import { invokeDesktopCommand } from '@/desktop/electron/invoke'
+import { getDesktopHost, isDesktop } from "@/desktop/host";
+import { invokeDesktopCommand } from "@/desktop/electron/invoke";
 
-export type DesktopDaemonState = 'starting' | 'running' | 'stopped' | 'errored'
+export type DesktopDaemonState = "starting" | "running" | "stopped" | "errored";
 
 export type DesktopDaemonStatus = {
-  serverId: string
-  status: DesktopDaemonState
-  listen: string
-  hostname: string | null
-  pid: number | null
-  home: string
-  error: string | null
-}
+  serverId: string;
+  status: DesktopDaemonState;
+  listen: string;
+  hostname: string | null;
+  pid: number | null;
+  home: string;
+  error: string | null;
+};
 
 export type DesktopDaemonLogs = {
-  logPath: string
-  contents: string
-}
+  logPath: string;
+  contents: string;
+};
 
 export type DesktopPairingOffer = {
-  relayEnabled: boolean
-  url: string | null
-  qr: string | null
-}
+  relayEnabled: boolean;
+  url: string | null;
+  qr: string | null;
+};
 
 export type CliSymlinkInstructions = {
-  title: string
-  detail: string
-  commands: string
-}
+  title: string;
+  detail: string;
+  commands: string;
+};
 
 export type LocalTransportTarget = {
-  transportType: 'socket' | 'pipe'
-  transportPath: string
-}
+  transportType: "socket" | "pipe";
+  transportPath: string;
+};
 
 type LocalTransportEventPayload = {
-  sessionId: string
-  kind: 'open' | 'message' | 'close' | 'error'
-  text?: string | null
-  binaryBase64?: string | null
-  code?: number | null
-  reason?: string | null
-  error?: string | null
-}
+  sessionId: string;
+  kind: "open" | "message" | "close" | "error";
+  text?: string | null;
+  binaryBase64?: string | null;
+  code?: number | null;
+  reason?: string | null;
+  error?: string | null;
+};
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
+  return typeof value === "object" && value !== null;
 }
 
 function toStringOrNull(value: unknown): string | null {
-  return typeof value === 'string' && value.trim().length > 0 ? value : null
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
 
 function toNumberOrNull(value: unknown): number | null {
-  return typeof value === 'number' && Number.isFinite(value) ? value : null
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
 function parseDesktopDaemonState(value: unknown): DesktopDaemonState {
-  const normalized = toStringOrNull(value)?.toLowerCase()
+  const normalized = toStringOrNull(value)?.toLowerCase();
   switch (normalized) {
-    case 'starting':
-      return 'starting'
-    case 'running':
-      return 'running'
-    case 'errored':
-    case 'error':
-      return 'errored'
-    case 'stopped':
-    case 'stopping':
-    case 'unknown':
+    case "starting":
+      return "starting";
+    case "running":
+      return "running";
+    case "errored":
+    case "error":
+      return "errored";
+    case "stopped":
+    case "stopping":
+    case "unknown":
     default:
-      return 'stopped'
+      return "stopped";
   }
 }
 
 function parseDesktopDaemonStatus(raw: unknown): DesktopDaemonStatus {
   if (!isRecord(raw)) {
-    throw new Error('Unexpected desktop daemon status response.')
+    throw new Error("Unexpected desktop daemon status response.");
   }
   return {
-    serverId: toStringOrNull(raw.serverId) ?? '',
+    serverId: toStringOrNull(raw.serverId) ?? "",
     status: parseDesktopDaemonState(raw.status),
-    listen: toStringOrNull(raw.listen) ?? '',
+    listen: toStringOrNull(raw.listen) ?? "",
     hostname: toStringOrNull(raw.hostname),
     pid: toNumberOrNull(raw.pid),
-    home: toStringOrNull(raw.home) ?? '',
+    home: toStringOrNull(raw.home) ?? "",
     error: toStringOrNull(raw.error),
-  }
+  };
 }
 
 function parseDesktopDaemonLogs(raw: unknown): DesktopDaemonLogs {
   if (!isRecord(raw)) {
-    throw new Error('Unexpected desktop daemon logs response.')
+    throw new Error("Unexpected desktop daemon logs response.");
   }
   return {
-    logPath: toStringOrNull(raw.logPath) ?? '',
-    contents: typeof raw.contents === 'string' ? raw.contents : '',
-  }
+    logPath: toStringOrNull(raw.logPath) ?? "",
+    contents: typeof raw.contents === "string" ? raw.contents : "",
+  };
 }
 
 function parseDesktopPairingOffer(raw: unknown): DesktopPairingOffer {
   if (!isRecord(raw)) {
-    throw new Error('Unexpected desktop daemon pairing response.')
+    throw new Error("Unexpected desktop daemon pairing response.");
   }
   return {
     relayEnabled: raw.relayEnabled === true,
     url: toStringOrNull(raw.url),
     qr: toStringOrNull(raw.qr),
-  }
+  };
 }
 
 function parseCliSymlinkInstructionsInternal(raw: unknown): CliSymlinkInstructions | null {
   if (!isRecord(raw)) {
-    return null
+    return null;
   }
   return {
-    title: toStringOrNull(raw.title) ?? '',
-    detail: toStringOrNull(raw.detail) ?? '',
-    commands: toStringOrNull(raw.commands) ?? '',
-  }
+    title: toStringOrNull(raw.title) ?? "",
+    detail: toStringOrNull(raw.detail) ?? "",
+    commands: toStringOrNull(raw.commands) ?? "",
+  };
 }
 
 export function shouldUseDesktopDaemon(): boolean {
-  return isDesktop()
+  return isDesktop();
 }
 
 export async function getDesktopDaemonStatus(): Promise<DesktopDaemonStatus> {
-  return parseDesktopDaemonStatus(await invokeDesktopCommand('desktop_daemon_status'))
+  return parseDesktopDaemonStatus(await invokeDesktopCommand("desktop_daemon_status"));
 }
 
 export async function startDesktopDaemon(): Promise<DesktopDaemonStatus> {
-  return parseDesktopDaemonStatus(await invokeDesktopCommand('start_desktop_daemon'))
+  return parseDesktopDaemonStatus(await invokeDesktopCommand("start_desktop_daemon"));
 }
 
 export async function stopDesktopDaemon(): Promise<DesktopDaemonStatus> {
-  return parseDesktopDaemonStatus(await invokeDesktopCommand('stop_desktop_daemon'))
+  return parseDesktopDaemonStatus(await invokeDesktopCommand("stop_desktop_daemon"));
 }
 
 export async function restartDesktopDaemon(): Promise<DesktopDaemonStatus> {
-  return parseDesktopDaemonStatus(await invokeDesktopCommand('restart_desktop_daemon'))
+  return parseDesktopDaemonStatus(await invokeDesktopCommand("restart_desktop_daemon"));
 }
 
 export async function getDesktopDaemonLogs(): Promise<DesktopDaemonLogs> {
-  return parseDesktopDaemonLogs(await invokeDesktopCommand('desktop_daemon_logs'))
+  return parseDesktopDaemonLogs(await invokeDesktopCommand("desktop_daemon_logs"));
 }
 
 export async function getDesktopDaemonPairing(): Promise<DesktopPairingOffer> {
-  return parseDesktopPairingOffer(await invokeDesktopCommand('desktop_daemon_pairing'))
+  return parseDesktopPairingOffer(await invokeDesktopCommand("desktop_daemon_pairing"));
 }
 
 export function parseCliSymlinkInstructions(raw: unknown): CliSymlinkInstructions {
-  const instructions = parseCliSymlinkInstructionsInternal(raw)
+  const instructions = parseCliSymlinkInstructionsInternal(raw);
   if (!instructions) {
-    throw new Error('Unexpected CLI symlink instructions response.')
+    throw new Error("Unexpected CLI symlink instructions response.");
   }
-  return instructions
+  return instructions;
 }
 
 export async function getCliSymlinkInstructions(): Promise<CliSymlinkInstructions> {
-  return parseCliSymlinkInstructions(await invokeDesktopCommand('cli_symlink_instructions'))
+  return parseCliSymlinkInstructions(await invokeDesktopCommand("cli_symlink_instructions"));
 }
 
-export type LocalTransportEventUnlisten = () => void
-export type LocalTransportEventHandler = (payload: LocalTransportEventPayload) => void
+export type LocalTransportEventUnlisten = () => void;
+export type LocalTransportEventHandler = (payload: LocalTransportEventPayload) => void;
 
 export async function listenToLocalTransportEvents(
-  handler: LocalTransportEventHandler
+  handler: LocalTransportEventHandler,
 ): Promise<LocalTransportEventUnlisten> {
-  const listen = getDesktopHost()?.events?.on
-  if (typeof listen !== 'function') {
-    throw new Error('Desktop events API is unavailable.')
+  const listen = getDesktopHost()?.events?.on;
+  if (typeof listen !== "function") {
+    throw new Error("Desktop events API is unavailable.");
   }
-  const unlisten = await listen('local-daemon-transport-event', (payload: unknown) => {
+  const unlisten = await listen("local-daemon-transport-event", (payload: unknown) => {
     if (!isRecord(payload)) {
-      return
+      return;
     }
     handler({
-      sessionId: toStringOrNull(payload.sessionId) ?? '',
-      kind: (toStringOrNull(payload.kind) ?? 'error') as LocalTransportEventPayload['kind'],
+      sessionId: toStringOrNull(payload.sessionId) ?? "",
+      kind: (toStringOrNull(payload.kind) ?? "error") as LocalTransportEventPayload["kind"],
       text: toStringOrNull(payload.text),
       binaryBase64: toStringOrNull(payload.binaryBase64),
       code: toNumberOrNull(payload.code),
       reason: toStringOrNull(payload.reason),
       error: toStringOrNull(payload.error),
-    })
-  })
-  return typeof unlisten === 'function' ? unlisten : () => {}
+    });
+  });
+  return typeof unlisten === "function" ? unlisten : () => {};
 }
 
 export async function openLocalTransportSession(target: LocalTransportTarget): Promise<string> {
-  const raw = await invokeDesktopCommand<unknown>('open_local_daemon_transport', target)
-  if (typeof raw !== 'string' || raw.trim().length === 0) {
-    throw new Error('Unexpected local transport session response.')
+  const raw = await invokeDesktopCommand<unknown>("open_local_daemon_transport", target);
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    throw new Error("Unexpected local transport session response.");
   }
-  return raw
+  return raw;
 }
 
 export async function sendLocalTransportMessage(input: {
-  sessionId: string
-  text?: string
-  binaryBase64?: string
+  sessionId: string;
+  text?: string;
+  binaryBase64?: string;
 }): Promise<void> {
-  await invokeDesktopCommand('send_local_daemon_transport_message', {
+  await invokeDesktopCommand("send_local_daemon_transport_message", {
     sessionId: input.sessionId,
     ...(input.text ? { text: input.text } : {}),
     ...(input.binaryBase64 ? { binaryBase64: input.binaryBase64 } : {}),
-  })
+  });
 }
 
 export async function closeLocalTransportSession(sessionId: string): Promise<void> {
-  await invokeDesktopCommand('close_local_daemon_transport', { sessionId })
+  await invokeDesktopCommand("close_local_daemon_transport", { sessionId });
 }