vite-plugin-ai-annotator 1.0.0

package/dist/mcp/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * InstantCode MCP Server
+ *
+ * Provides MCP tools for Claude Desktop/Claude Code to interact with
+ * browser elements through the InstantCode inspector.
+ */
+export {};

package/dist/rpc/client.generated.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ⚠️  DO NOT EDIT THIS FILE - IT IS AUTO-GENERATED ⚠️
+ *
+ * Auto-generated client RPC from define.ts
+ *
+ * Usage:
+ *   const client = createRpcClient(socket);
+ *   client.handle.eventName(async (data) => { ... });
+ *   client.server.methodName(args);
+ *   client.dispose();
+ *
+ * To regenerate: bunx socketrpc-gen /Volumes/Data/Projects/instantcode/app/src/rpc/define.ts
+ */
+import type { Socket } from "socket.io-client";
+import type { RpcError } from "./types.generated";
+import type { BrowserSession, PageContext, ElementData, SelectionResult, ScreenshotResult, InjectResult, ConsoleEntry } from "./define";
+/** Handler registration methods - implement these to handle calls from server */
+export interface RpcClientHandle {
+    /** Register handler for 'getPageContext' - called by server */
+    getPageContext: (handler: () => Promise<PageContext | RpcError>) => void;
+    /** Register handler for 'getSelectedElements' - called by server */
+    getSelectedElements: (handler: () => Promise<ElementData[] | RpcError>) => void;
+    /** Register handler for 'triggerSelection' - called by server */
+    triggerSelection: (handler: (mode: "inspect" | "selector", selector: string | undefined, selectorType: "css" | "xpath" | undefined) => Promise<SelectionResult | RpcError>) => void;
+    /** Register handler for 'captureScreenshot' - called by server */
+    captureScreenshot: (handler: (type: "viewport" | "element", selector: string | undefined, format: "png" | "jpeg" | undefined, quality: number | undefined) => Promise<ScreenshotResult | RpcError>) => void;
+    /** Register handler for 'clearSelection' - called by server */
+    clearSelection: (handler: () => Promise<void | RpcError>) => void;
+    /** Register handler for 'injectCSS' - called by server */
+    injectCSS: (handler: (css: string) => Promise<InjectResult | RpcError>) => void;
+    /** Register handler for 'injectJS' - called by server */
+    injectJS: (handler: (code: string) => Promise<InjectResult | RpcError>) => void;
+    /** Register handler for 'getConsole' - called by server */
+    getConsole: (handler: (clear: boolean | undefined) => Promise<ConsoleEntry[] | RpcError>) => void;
+    /** Register handler for 'ping' - called by server */
+    ping: (handler: () => Promise<string | RpcError>) => void;
+    /** Register handler for RPC errors */
+    rpcError: (handler: (error: RpcError) => void) => void;
+}
+/** Methods to call server */
+export interface RpcClientServer {
+    /** Call server's 'getSessions' method */
+    getSessions: (timeout?: number) => Promise<BrowserSession[] | RpcError>;
+    /** Call server's 'ping' method */
+    ping: (timeout?: number) => Promise<string | RpcError>;
+}
+/** Client RPC interface with ergonomic API. */
+/** Use `.handle` to register handlers, `.server` to call server methods, and `.dispose()` to cleanup. */
+export interface RpcClient {
+    /** Register handlers for calls from server */
+    readonly handle: RpcClientHandle;
+    /** Call server methods */
+    readonly server: RpcClientServer;
+    /** The underlying socket instance */
+    readonly socket: Socket;
+    /** Whether this instance has been disposed */
+    readonly disposed: boolean;
+    /** Cleanup all registered handlers. Call this when done (e.g., in onBeforeUnmount or useEffect cleanup). */
+    dispose(): void;
+}
+/**
+ * Create a client RPC instance.
+ *
+ * Usage:
+ * ```typescript
+ * const client = createRpcClient(socket);
+ *
+ * // Register handlers for calls from server
+ * client.handle.getPageContext(async (data) => {
+ *   // handle event
+ * });
+ *
+ * // Call server methods
+ * const result = await client.server.getSessions();
+ *
+ * // Cleanup when done
+ * client.dispose();
+ * ```
+ * @param socket The socket instance
+ * @returns RpcClient instance with .handle, .server, and .dispose()
+ */
+export declare function createRpcClient(socket: Socket): RpcClient;

package/dist/rpc/define.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Socket RPC Interface Definitions for InstantCode
+ *
+ * Server: WebSocket server running on port 7318
+ * Client: Browser annotator toolbar
+ */
+export interface PageContext {
+    url: string;
+    title: string;
+    selectionCount: number;
+    isInspecting: boolean;
+}
+export interface ElementData {
+    index: number;
+    tagName: string;
+    xpath: string;
+    cssSelector: string;
+    textContent: string;
+    attributes: Record<string, string>;
+    imagePath?: string;
+    comment?: string;
+    computedStyles?: {
+        width: number;
+        height: number;
+        fontSize: string;
+        fontFamily: string;
+        color?: string;
+        backgroundColor?: string;
+        display?: string;
+        position?: string;
+    };
+    componentData?: {
+        componentLocation: string;
+        componentName?: string;
+        framework?: 'vue' | 'react' | 'angular' | 'svelte' | 'vanilla';
+    };
+    children: ElementData[];
+}
+export interface ScreenshotResult {
+    success: boolean;
+    base64?: string;
+    filePath?: string;
+    error?: string;
+}
+export interface ConsoleEntry {
+    type: 'log' | 'info' | 'warn' | 'error' | 'debug';
+    args: string[];
+    timestamp: number;
+}
+export interface InjectResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+}
+export interface SelectionResult {
+    success: boolean;
+    count: number;
+    error?: string;
+}
+export interface BrowserSession {
+    id: string;
+    url: string;
+    title: string;
+    connectedAt: number;
+    lastActivity: number;
+}
+export interface ServerFunctions {
+    getSessions: () => BrowserSession[];
+    ping: () => string;
+}
+export interface ClientFunctions {
+    getPageContext: () => PageContext;
+    getSelectedElements: () => ElementData[];
+    triggerSelection: (mode: 'inspect' | 'selector', selector?: string, selectorType?: 'css' | 'xpath') => SelectionResult;
+    captureScreenshot: (type: 'viewport' | 'element', selector?: string, format?: 'png' | 'jpeg', quality?: number) => ScreenshotResult;
+    clearSelection: () => void;
+    injectCSS: (css: string) => InjectResult;
+    injectJS: (code: string) => InjectResult;
+    getConsole: (clear?: boolean) => ConsoleEntry[];
+    ping: () => string;
+}

package/dist/rpc/server.generated.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ⚠️  DO NOT EDIT THIS FILE - IT IS AUTO-GENERATED ⚠️
+ *
+ * Auto-generated server RPC from define.ts
+ *
+ * Usage:
+ *   const server = createRpcServer(socket);
+ *   server.handle.eventName(async (data) => { ... });
+ *   server.client.methodName(args);
+ *   server.dispose();
+ *
+ * To regenerate: bunx socketrpc-gen /Volumes/Data/Projects/instantcode/app/src/rpc/define.ts
+ */
+import type { Socket } from "socket.io";
+import type { RpcError } from "./types.generated";
+import type { BrowserSession, PageContext, ElementData, SelectionResult, ScreenshotResult, InjectResult, ConsoleEntry } from "./define";
+/** Handler registration methods - implement these to handle calls from client */
+export interface RpcServerHandle {
+    /** Register handler for 'getSessions' - called by client */
+    getSessions: (handler: () => Promise<BrowserSession[] | RpcError>) => void;
+    /** Register handler for 'ping' - called by client */
+    ping: (handler: () => Promise<string | RpcError>) => void;
+    /** Register handler for RPC errors */
+    rpcError: (handler: (error: RpcError) => void) => void;
+}
+/** Methods to call client */
+export interface RpcServerClient {
+    /** Call client's 'getPageContext' method */
+    getPageContext: (timeout?: number) => Promise<PageContext | RpcError>;
+    /** Call client's 'getSelectedElements' method */
+    getSelectedElements: (timeout?: number) => Promise<ElementData[] | RpcError>;
+    /** Call client's 'triggerSelection' method */
+    triggerSelection: (mode: "inspect" | "selector", selector: string | undefined, selectorType: "css" | "xpath" | undefined, timeout?: number) => Promise<SelectionResult | RpcError>;
+    /** Call client's 'captureScreenshot' method */
+    captureScreenshot: (type: "viewport" | "element", selector: string | undefined, format: "png" | "jpeg" | undefined, quality: number | undefined, timeout?: number) => Promise<ScreenshotResult | RpcError>;
+    /** Call client's 'clearSelection' method */
+    clearSelection: () => void;
+    /** Call client's 'injectCSS' method */
+    injectCSS: (css: string, timeout?: number) => Promise<InjectResult | RpcError>;
+    /** Call client's 'injectJS' method */
+    injectJS: (code: string, timeout?: number) => Promise<InjectResult | RpcError>;
+    /** Call client's 'getConsole' method */
+    getConsole: (clear: boolean | undefined, timeout?: number) => Promise<ConsoleEntry[] | RpcError>;
+    /** Call client's 'ping' method */
+    ping: (timeout?: number) => Promise<string | RpcError>;
+}
+/** Server RPC interface with ergonomic API. */
+/** Use `.handle` to register handlers, `.client` to call client methods, and `.dispose()` to cleanup. */
+export interface RpcServer {
+    /** Register handlers for calls from client */
+    readonly handle: RpcServerHandle;
+    /** Call client methods */
+    readonly client: RpcServerClient;
+    /** The underlying socket instance */
+    readonly socket: Socket;
+    /** Whether this instance has been disposed */
+    readonly disposed: boolean;
+    /** Cleanup all registered handlers. Call this when done (e.g., in onBeforeUnmount or useEffect cleanup). */
+    dispose(): void;
+}
+/**
+ * Create a server RPC instance.
+ *
+ * Usage:
+ * ```typescript
+ * const server = createRpcServer(socket);
+ *
+ * // Register handlers for calls from client
+ * server.handle.getSessions(async (data) => {
+ *   // handle event
+ * });
+ *
+ * // Call client methods
+ * const result = await server.client.getPageContext();
+ *
+ * // Cleanup when done
+ * server.dispose();
+ * ```
+ * @param socket The socket instance
+ * @returns RpcServer instance with .handle, .client, and .dispose()
+ */
+export declare function createRpcServer(socket: Socket): RpcServer;

package/dist/rpc/types.generated.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ⚠️  DO NOT EDIT THIS FILE - IT IS AUTO-GENERATED ⚠️
+ *
+ * Auto-generated types for the RPC package
+ *
+ * To regenerate this file, run:
+ * bunx socketrpc-gen /Volumes/Data/Projects/instantcode/app/src/rpc/define.ts
+ */
+/** Function to unsubscribe from an event listener. Call this to clean up the listener. */
+export type UnsubscribeFunction = () => void;
+/** Represents an error that occurred during an RPC call. */
+export interface RpcError {
+    /** The error message. */
+    message: string;
+    /** The error code. */
+    code: string;
+    /** The error data. */
+    data: any;
+}
+/** Type guard to check if an object is an RpcError. */
+export declare function isRpcError(obj: any): obj is RpcError;

package/dist/shared/schemas.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const WSMessageSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        request: "request";
+        response: "response";
+        event: "event";
+    }>;
+    requestId: z.ZodOptional<z.ZodString>;
+    action: z.ZodString;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type WSMessage = z.infer<typeof WSMessageSchema>;
+export declare const WSActionSchema: z.ZodEnum<{
+    ping: "ping";
+    get_page_context: "get_page_context";
+    get_selected_elements: "get_selected_elements";
+    trigger_selection: "trigger_selection";
+    select_by_selector: "select_by_selector";
+    capture_screenshot: "capture_screenshot";
+    clear_selection: "clear_selection";
+}>;
+export type WSAction = z.infer<typeof WSActionSchema>;
+export declare const PageContextSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodString;
+    selectionCount: z.ZodNumber;
+    isInspecting: z.ZodBoolean;
+}, z.core.$strip>;
+export type PageContext = z.infer<typeof PageContextSchema>;
+export declare const ScreenshotOptionsSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        viewport: "viewport";
+        element: "element";
+    }>>;
+    selector: z.ZodOptional<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+    }>>;
+    quality: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScreenshotOptions = z.infer<typeof ScreenshotOptionsSchema>;
+export declare const SelectionTriggerSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        inspect: "inspect";
+        selector: "selector";
+    }>>;
+    selector: z.ZodOptional<z.ZodString>;
+    selectorType: z.ZodDefault<z.ZodEnum<{
+        css: "css";
+        xpath: "xpath";
+    }>>;
+}, z.core.$strip>;
+export type SelectionTrigger = z.infer<typeof SelectionTriggerSchema>;
+export declare const BrowserSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodString;
+    connectedAt: z.ZodNumber;
+    lastActivity: z.ZodNumber;
+}, z.core.$strip>;
+export type BrowserSession = z.infer<typeof BrowserSessionSchema>;
+declare const ElementDataBaseSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    tagName: z.ZodString;
+    xpath: z.ZodString;
+    cssSelector: z.ZodString;
+    textContent: z.ZodString;
+    attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    imagePath: z.ZodOptional<z.ZodString>;
+    comment: z.ZodOptional<z.ZodString>;
+    computedStyles: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        fontSize: z.ZodString;
+        fontFamily: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        display: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    componentData: z.ZodOptional<z.ZodObject<{
+        componentLocation: z.ZodString;
+        componentName: z.ZodOptional<z.ZodString>;
+        elementLocation: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        framework: z.ZodOptional<z.ZodEnum<{
+            vue: "vue";
+            react: "react";
+            angular: "angular";
+            svelte: "svelte";
+            vanilla: "vanilla";
+        }>>;
+        sourceMap: z.ZodOptional<z.ZodObject<{
+            originalLine: z.ZodNumber;
+            originalColumn: z.ZodNumber;
+            originalSource: z.ZodString;
+            originalName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        sourceHierarchy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ElementDataType = z.infer<typeof ElementDataBaseSchema> & {
+    children: ElementDataType[];
+};
+export declare const ElementDataSchema: z.ZodType<ElementDataType>;
+export declare const PageInfoSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+export type ElementData = z.infer<typeof ElementDataSchema>;
+export type PageInfo = z.infer<typeof PageInfoSchema>;
+export {};

package/dist/shared/types.d.ts

@@ -0,0 +1 @@
+export type { ElementData, PageInfo, } from './schemas';

package/dist/trpc/context.d.ts

@@ -0,0 +1,28 @@
+import type { CreateExpressContextOptions } from '@trpc/server/adapters/express';
+import type { CreateWSSContextFnOptions } from '@trpc/server/adapters/ws';
+/**
+ * Inner context - always available in procedures
+ * Used for shared data like database connections
+ */
+export declare function createContextInner(verbose?: boolean): Promise<{
+    verbose: boolean;
+    logger: import("../utils/logger").Logger;
+}>;
+/**
+ * Context for Express HTTP requests
+ */
+export declare function createContext(opts: CreateExpressContextOptions, verbose?: boolean): Promise<{
+    req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    res: import("express").Response<any, Record<string, any>>;
+    verbose: boolean;
+    logger: import("../utils/logger").Logger;
+}>;
+/**
+ * Context for WebSocket connections
+ */
+export declare function createWSSContext(opts: CreateWSSContextFnOptions, verbose?: boolean): Promise<{
+    req: import("http").IncomingMessage;
+    verbose: boolean;
+    logger: import("../utils/logger").Logger;
+}>;
+export type Context = Awaited<ReturnType<typeof createContextInner>>;

package/dist/trpc/router.d.ts

@@ -0,0 +1,195 @@
+export declare const router: import("@trpc/server").TRPCRouterBuilder<{
+    ctx: {
+        verbose: boolean;
+        logger: import("../utils/logger").Logger;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}>;
+export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
+    verbose: boolean;
+    logger: import("../utils/logger").Logger;
+}, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        verbose: boolean;
+        logger: import("../utils/logger").Logger;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    health: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            status: string;
+            timestamp: string;
+        };
+        meta: object;
+    }>;
+    newChat: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    sendMessage: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            userPrompt: string;
+            selectedElements: {
+                index: number;
+                tagName: string;
+                xpath: string;
+                cssSelector: string;
+                textContent: string;
+                attributes: Record<string, string>;
+                children: any[];
+                imagePath?: string | undefined;
+                computedStyles?: {
+                    width: number;
+                    height: number;
+                    fontSize: string;
+                    fontFamily: string;
+                    color?: string | undefined;
+                    backgroundColor?: string | undefined;
+                    display?: string | undefined;
+                    position?: string | undefined;
+                } | undefined;
+                componentData?: {
+                    componentLocation: string;
+                    componentName?: string | undefined;
+                    elementLocation?: {
+                        file: string;
+                        line: number;
+                        column: number;
+                        endLine?: number | undefined;
+                        endColumn?: number | undefined;
+                        source?: string | undefined;
+                    } | undefined;
+                    framework?: "vue" | "react" | "angular" | "svelte" | "vanilla" | undefined;
+                    sourceMap?: {
+                        originalLine: number;
+                        originalColumn: number;
+                        originalSource: string;
+                        originalName?: string | undefined;
+                    } | undefined;
+                    sourceHierarchy?: string | undefined;
+                } | undefined;
+            }[];
+            pageInfo: {
+                url: string;
+                title: string;
+            };
+            cwd?: string | undefined;
+            sessionId?: string | undefined;
+            consoleErrors?: string[] | undefined;
+            consoleWarnings?: string[] | undefined;
+            consoleInfo?: string[] | undefined;
+        };
+        output: AsyncIterable<{
+            type: "system";
+            subtype: "init";
+            apiKeySource: "user" | "project" | "org" | "temporary";
+            cwd: string;
+            session_id: string;
+            tools: string[];
+            mcp_servers: {
+                name: string;
+                status: string;
+            }[];
+            model: string;
+            permissionMode: "default" | "acceptEdits" | "bypassPermissions" | "plan";
+            slash_commands: string[];
+        } | {
+            type: "assistant";
+            message: {
+                id: string;
+                type: "message";
+                role: "assistant";
+                model: string;
+                content: {
+                    type: string;
+                    text?: string | undefined;
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    input?: Record<string, unknown> | undefined;
+                }[];
+                stop_reason?: string | null | undefined;
+                stop_sequence?: string | null | undefined;
+                usage?: {
+                    input_tokens: number;
+                    output_tokens: number;
+                    cache_creation_input_tokens?: number | undefined;
+                    cache_read_input_tokens?: number | undefined;
+                } | undefined;
+            };
+            parent_tool_use_id: string | null;
+            session_id: string;
+        } | {
+            type: "user";
+            message: {
+                role: "user";
+                content: {
+                    type: string;
+                    content?: string | undefined;
+                    tool_use_id?: string | undefined;
+                }[];
+            };
+            parent_tool_use_id: string | null;
+            session_id: string;
+        } | {
+            type: "result";
+            subtype: "success";
+            duration_ms: number;
+            duration_api_ms: number;
+            is_error: false;
+            num_turns: number;
+            result: string;
+            session_id: string;
+            total_cost_usd: number;
+            usage: {
+                input_tokens: number;
+                cache_creation_input_tokens: number;
+                cache_read_input_tokens: number;
+                output_tokens: number;
+            };
+            permission_denials: {
+                tool_name: string;
+                tool_use_id: string;
+                tool_input: Record<string, unknown>;
+            }[];
+        } | {
+            type: "result";
+            subtype: "error_max_turns" | "error_during_execution";
+            duration_ms: number;
+            duration_api_ms: number;
+            is_error: true;
+            num_turns: number;
+            session_id: string;
+            total_cost_usd: number;
+            usage: {
+                input_tokens: number;
+                cache_creation_input_tokens: number;
+                cache_read_input_tokens: number;
+                output_tokens: number;
+            };
+            permission_denials: {
+                tool_name: string;
+                tool_use_id: string;
+                tool_input: Record<string, unknown>;
+            }[];
+        } | {
+            type: "result";
+            subtype: "error";
+            is_error: true;
+            duration_ms: number;
+            duration_api_ms: number;
+            result: string;
+            session_id?: string | undefined;
+        }, void, any>;
+        meta: object;
+    }>;
+}>>;
+export type AppRouter = typeof appRouter;

package/dist/trpc-server.d.ts

@@ -0,0 +1,14 @@
+import type { Express } from 'express';
+import type { Server } from 'node:http';
+import { WebSocketServer } from 'ws';
+export interface ServerInstance {
+    app: Express;
+    server: Server;
+    wss: WebSocketServer;
+    port: number;
+    listenAddress: string;
+    publicAddress: string;
+    verbose: boolean;
+}
+export declare function startServer(port: number, listenAddress: string, publicAddress: string, verbose?: boolean): Promise<ServerInstance>;
+export declare function stopServer(serverInstance: ServerInstance): Promise<void>;

package/dist/utils/html.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTML utilities for safe text handling and string hashing
+ */
+export declare class HtmlUtils {
+    static escapeHtml(text: string): string;
+    static hashString(content: string): string;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Server-side logging utility
+ */
+export interface Logger {
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export declare function createLogger(verbose: boolean): Logger;
+export declare function createSilentLogger(): Logger;