style: fix biome lint/format on RPC files

Author: ualtinok

packages/plugin/src/index.ts

@@ -15,13 +15,13 @@ import { startDreamScheduleTimer } from "./plugin/dream-timer";
 import { createEventHandler } from "./plugin/event";
 import { createSessionHooks } from "./plugin/hooks/create-session-hooks";
 import { createMessagesTransformHandler } from "./plugin/messages-transform";
-import { createToolRegistry } from "./plugin/tool-registry";
 import { registerRpcHandlers } from "./plugin/rpc-handlers";
+import { createToolRegistry } from "./plugin/tool-registry";
 import { type ConflictResult, detectConflicts } from "./shared/conflict-detector";
 import { getOpenCodeStorageDir } from "./shared/data-path";
-import { MagicContextRpcServer } from "./shared/rpc-server";
 import { log } from "./shared/logger";
 import { getAgentFallbackModels } from "./shared/model-requirements";
+import { MagicContextRpcServer } from "./shared/rpc-server";
 
 const plugin: Plugin = async (ctx) => {
     const pluginConfig = loadPluginConfig(ctx.directory);

packages/plugin/src/plugin/rpc-handlers.ts

@@ -4,12 +4,12 @@
  */
 import type { Database } from "bun:sqlite";
 import type { MagicContextConfig } from "../config/schema/magic-context";
+import { resolveProjectIdentity } from "../features/magic-context/memory/project-identity";
 import { openDatabase } from "../features/magic-context/storage";
+import { log } from "../shared/logger";
 import { drainNotifications } from "../shared/rpc-notifications";
 import type { MagicContextRpcServer } from "../shared/rpc-server";
 import type { SidebarSnapshot, StatusDetail } from "../shared/rpc-types";
-import { log } from "../shared/logger";
-import { resolveProjectIdentity } from "../features/magic-context/memory/project-identity";
 
 function getDb(): Database | null {
     try {
@@ -57,11 +57,7 @@ function resolveConfigValue<T>(
     return defaultValue;
 }
 
-function buildSidebarSnapshot(
-    db: Database,
-    sessionId: string,
-    directory: string,
-): SidebarSnapshot {
+function buildSidebarSnapshot(db: Database, sessionId: string, directory: string): SidebarSnapshot {
     const empty: SidebarSnapshot = {
         sessionId,
         usagePercentage: 0,
@@ -471,9 +467,7 @@ export function registerRpcHandlers(
         const sessionId = String(params.sessionId ?? "");
         if (!sessionId) return { ok: false, error: "no session" };
 
-        const { executeContextRecomp } = await import(
-            "../hooks/magic-context/compartment-runner"
-        );
+        const { executeContextRecomp } = await import("../hooks/magic-context/compartment-runner");
         const { sendIgnoredMessage } = await import(
             "../hooks/magic-context/send-session-notification"
         );

packages/plugin/src/shared/rpc-client.ts

@@ -24,14 +24,11 @@ export class MagicContextRpcClient {
             throw new Error("Magic Context RPC server not available");
         }
 
-        const response = await this.fetchWithTimeout(
-            `http://127.0.0.1:${port}/rpc/${method}`,
-            {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(params),
-            },
-        );
+        const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+        });
 
         if (!response.ok) {
             const text = await response.text();
@@ -100,10 +97,9 @@ export class MagicContextRpcClient {
 
     private async healthCheck(port: number): Promise<boolean> {
         try {
-            const response = await this.fetchWithTimeout(
-                `http://127.0.0.1:${port}/health`,
-                { method: "GET" },
-            );
+            const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+                method: "GET",
+            });
             return response.ok;
         } catch {
             return false;

packages/plugin/src/shared/rpc-server.ts

@@ -1,10 +1,5 @@
 import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import {
-    createServer,
-    type IncomingMessage,
-    type Server,
-    type ServerResponse,
-} from "node:http";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { dirname } from "node:path";
 import { log } from "./logger";
 import { rpcPortFilePath } from "./rpc-utils";

packages/plugin/src/tui/data/context-db.ts

@@ -2,30 +2,30 @@
  * TUI data layer — pure RPC client, no direct SQLite access.
  * All data is fetched from the server plugin via HTTP RPC.
  */
-import os from "node:os"
-import path from "node:path"
-import { MagicContextRpcClient } from "../../shared/rpc-client"
-import type { SidebarSnapshot, StatusDetail, RpcNotificationMessage } from "../../shared/rpc-types"
+import os from "node:os";
+import path from "node:path";
+import { MagicContextRpcClient } from "../../shared/rpc-client";
+import type { RpcNotificationMessage, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
 
-export type { SidebarSnapshot, StatusDetail }
+export type { SidebarSnapshot, StatusDetail };
 
-let rpcClient: MagicContextRpcClient | null = null
+let rpcClient: MagicContextRpcClient | null = null;
 
 function getStorageDir(): string {
-    const dataDir = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share")
-    return path.join(dataDir, "opencode", "storage", "plugin", "magic-context")
+    const dataDir = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+    return path.join(dataDir, "opencode", "storage", "plugin", "magic-context");
 }
 
 /** Initialize the RPC client. Call once on TUI startup. */
 export function initRpcClient(directory: string): void {
-    const storageDir = getStorageDir()
-    rpcClient = new MagicContextRpcClient(storageDir, directory)
+    const storageDir = getStorageDir();
+    rpcClient = new MagicContextRpcClient(storageDir, directory);
 }
 
 /** Clean up the RPC client. */
 export function closeRpc(): void {
-    rpcClient?.reset()
-    rpcClient = null
+    rpcClient?.reset();
+    rpcClient = null;
 }
 
 const EMPTY_SNAPSHOT: SidebarSnapshot = {
@@ -48,25 +48,25 @@ const EMPTY_SNAPSHOT: SidebarSnapshot = {
     compartmentTokens: 0,
     factTokens: 0,
     memoryTokens: 0,
-}
+};
 
 /** Fetch sidebar snapshot from the server via RPC. */
 export async function loadSidebarSnapshot(
     sessionId: string,
     directory: string,
 ): Promise<SidebarSnapshot> {
-    if (!rpcClient) return { ...EMPTY_SNAPSHOT, sessionId }
+    if (!rpcClient) return { ...EMPTY_SNAPSHOT, sessionId };
     try {
         const result = await rpcClient.call<SidebarSnapshot>("sidebar-snapshot", {
             sessionId,
             directory,
-        })
+        });
         if ((result as unknown as Record<string, unknown>).error) {
-            return { ...EMPTY_SNAPSHOT, sessionId }
+            return { ...EMPTY_SNAPSHOT, sessionId };
         }
-        return result
+        return result;
     } catch {
-        return { ...EMPTY_SNAPSHOT, sessionId }
+        return { ...EMPTY_SNAPSHOT, sessionId };
     }
 }
 
@@ -102,65 +102,65 @@ export async function loadStatusDetail(
         historyBlockTokens: 0,
         compressionBudget: null,
         compressionUsage: null,
-    }
+    };
 
-    if (!rpcClient) return emptyDetail
+    if (!rpcClient) return emptyDetail;
     try {
         const result = await rpcClient.call<StatusDetail>("status-detail", {
             sessionId,
             directory,
             modelKey,
-        })
+        });
         if ((result as unknown as Record<string, unknown>).error) {
-            return emptyDetail
+            return emptyDetail;
         }
-        return result
+        return result;
     } catch {
-        return emptyDetail
+        return emptyDetail;
     }
 }
 
 /** Get compartment count via RPC. */
 export async function getCompartmentCount(sessionId: string): Promise<number> {
-    if (!rpcClient) return 0
+    if (!rpcClient) return 0;
     try {
-        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId })
-        return result.count ?? 0
+        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId });
+        return result.count ?? 0;
     } catch {
-        return 0
+        return 0;
     }
 }
 
 /** Send recomp request to server via RPC. */
 export async function requestRecomp(sessionId: string): Promise<boolean> {
-    if (!rpcClient) return false
+    if (!rpcClient) return false;
     try {
-        const result = await rpcClient.call<{ ok: boolean }>("recomp", { sessionId })
-        return result.ok ?? false
+        const result = await rpcClient.call<{ ok: boolean }>("recomp", { sessionId });
+        return result.ok ?? false;
     } catch {
-        return false
+        return false;
     }
 }
 
 export interface TuiMessage {
-    type: string
-    payload: Record<string, unknown>
-    sessionId?: string
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
 }
 
 /** Poll for pending server→TUI notifications via RPC. */
 export async function consumeTuiMessages(): Promise<TuiMessage[]> {
-    if (!rpcClient) return []
+    if (!rpcClient) return [];
     try {
         const result = await rpcClient.call<{ messages: RpcNotificationMessage[] }>(
             "pending-notifications",
-        )
+        );
         return (result.messages ?? []).map((m) => ({
             type: m.type,
             payload: m.payload,
             sessionId: m.sessionId,
-        }))
+        }));
     } catch {
-        return []
+        return [];
     }
 }