happy-coder 0.1.7 → 0.1.9

package/dist/lib.d.cts

@@ -0,0 +1,727 @@
+import { z } from 'zod';
+import { EventEmitter } from 'node:events';
+import { ExpoPushMessage } from 'expo-server-sdk';
+
+/**
+ * COPIED FROM https://github.com/ex3ndr/handy/blob/main/sources/sync/claude-code-schema.ts
+ * EDIT IN SYNC WITH ORIGINAL
+ */
+
+declare const UsageSchema: z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodNumber;
+    service_tier: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number | undefined;
+    cache_read_input_tokens?: number | undefined;
+    service_tier?: string | undefined;
+}, {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number | undefined;
+    cache_read_input_tokens?: number | undefined;
+    service_tier?: string | undefined;
+}>;
+declare const RawJSONLinesSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    cwd: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodString;
+    uuid: z.ZodString;
+    timestamp: z.ZodString;
+    parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+} & {
+    type: z.ZodLiteral<"user">;
+    message: z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            tool_use_id: z.ZodString;
+            type: z.ZodLiteral<"tool_result">;
+            content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+            }, {
+                type: "text";
+                text: string;
+            }>, "many">]>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        }, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>]>, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "user";
+    }, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "user";
+    }>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
+    toolUseResult: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    message: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "user";
+    };
+    type: "user";
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    isMeta?: boolean | undefined;
+    toolUseResult?: unknown;
+}, {
+    message: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "user";
+    };
+    type: "user";
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    isMeta?: boolean | undefined;
+    toolUseResult?: unknown;
+}>, z.ZodObject<{
+    cwd: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodString;
+    uuid: z.ZodString;
+    timestamp: z.ZodString;
+    parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+} & {
+    type: z.ZodLiteral<"assistant">;
+    message: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"message">;
+        role: z.ZodLiteral<"assistant">;
+        model: z.ZodString;
+        content: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"thinking">;
+            thinking: z.ZodString;
+            signature: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        }, {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        }, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        }>, z.ZodObject<{
+            tool_use_id: z.ZodString;
+            type: z.ZodLiteral<"tool_result">;
+            content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+            }, {
+                type: "text";
+                text: string;
+            }>, "many">]>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        }, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        }>]>, "many">;
+        stop_reason: z.ZodNullable<z.ZodString>;
+        stop_sequence: z.ZodNullable<z.ZodString>;
+        usage: z.ZodObject<{
+            input_tokens: z.ZodNumber;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodNumber;
+            service_tier: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        }, {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        };
+        type: "message";
+        id: string;
+        content: ({
+            type: "text";
+            text: string;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "assistant";
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    }, {
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        };
+        type: "message";
+        id: string;
+        content: ({
+            type: "text";
+            text: string;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "assistant";
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    }>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: {
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        };
+        type: "message";
+        id: string;
+        content: ({
+            type: "text";
+            text: string;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "assistant";
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    };
+    type: "assistant";
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    requestId?: string | undefined;
+}, {
+    message: {
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number | undefined;
+            cache_read_input_tokens?: number | undefined;
+            service_tier?: string | undefined;
+        };
+        type: "message";
+        id: string;
+        content: ({
+            type: "text";
+            text: string;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input?: unknown;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | {
+                type: "text";
+                text: string;
+            }[];
+            is_error?: boolean | undefined;
+        })[];
+        role: "assistant";
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    };
+    type: "assistant";
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    requestId?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"summary">;
+    summary: z.ZodString;
+    leafUuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "summary";
+    summary: string;
+    leafUuid: string;
+}, {
+    type: "summary";
+    summary: string;
+    leafUuid: string;
+}>, z.ZodObject<{
+    cwd: z.ZodString;
+    sessionId: z.ZodString;
+    version: z.ZodString;
+    uuid: z.ZodString;
+    timestamp: z.ZodString;
+    parent_tool_use_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+} & {
+    type: z.ZodLiteral<"system">;
+    content: z.ZodString;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
+    level: z.ZodOptional<z.ZodString>;
+    parentUuid: z.ZodOptional<z.ZodString>;
+    isSidechain: z.ZodOptional<z.ZodBoolean>;
+    userType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "system";
+    content: string;
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    isMeta?: boolean | undefined;
+    level?: string | undefined;
+    parentUuid?: string | undefined;
+    isSidechain?: boolean | undefined;
+    userType?: string | undefined;
+}, {
+    type: "system";
+    content: string;
+    cwd: string;
+    sessionId: string;
+    version: string;
+    uuid: string;
+    timestamp: string;
+    parent_tool_use_id?: string | null | undefined;
+    isMeta?: boolean | undefined;
+    level?: string | undefined;
+    parentUuid?: string | undefined;
+    isSidechain?: boolean | undefined;
+    userType?: string | undefined;
+}>]>;
+type RawJSONLines = z.infer<typeof RawJSONLinesSchema>;
+
+/**
+ * Usage data type from Claude
+ */
+type Usage = z.infer<typeof UsageSchema>;
+/**
+ * Session information
+ */
+declare const SessionSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    id: z.ZodString;
+    seq: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    metadata: z.ZodAny;
+    metadataVersion: z.ZodNumber;
+    agentState: z.ZodNullable<z.ZodAny>;
+    agentStateVersion: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    seq: number;
+    createdAt: number;
+    updatedAt: number;
+    metadataVersion: number;
+    agentStateVersion: number;
+    metadata?: any;
+    agentState?: any;
+}, {
+    id: string;
+    seq: number;
+    createdAt: number;
+    updatedAt: number;
+    metadataVersion: number;
+    agentStateVersion: number;
+    metadata?: any;
+    agentState?: any;
+}>;
+type Session = z.infer<typeof SessionSchema>;
+declare const UserMessageSchema: z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>;
+    localKey: z.ZodOptional<z.ZodString>;
+    sentFrom: z.ZodOptional<z.ZodEnum<["mobile", "cli"]>>;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    };
+    role: "user";
+    localKey?: string | undefined;
+    sentFrom?: "mobile" | "cli" | undefined;
+}, {
+    content: {
+        type: "text";
+        text: string;
+    };
+    role: "user";
+    localKey?: string | undefined;
+    sentFrom?: "mobile" | "cli" | undefined;
+}>;
+type UserMessage = z.infer<typeof UserMessageSchema>;
+type Metadata = {
+    path: string;
+    host: string;
+    version?: string;
+    name?: string;
+    usage?: {
+        [model: string]: {
+            input?: number;
+            input_cache?: number;
+            output?: number;
+            output_reasoning?: number;
+            usd?: number;
+        };
+    };
+};
+type AgentState = {
+    controlledByUser?: boolean | null | undefined;
+    requests?: {
+        [id: string]: {
+            tool: string;
+            arguments: any;
+        };
+    };
+};
+
+type RpcHandler<T = any, R = any> = (data: T) => R | Promise<R>;
+declare class ApiSessionClient extends EventEmitter {
+    private readonly token;
+    private readonly secret;
+    private readonly sessionId;
+    private metadata;
+    private metadataVersion;
+    private agentState;
+    private agentStateVersion;
+    private socket;
+    private pendingMessages;
+    private pendingMessageCallback;
+    private rpcHandlers;
+    constructor(token: string, secret: Uint8Array, session: Session);
+    onUserMessage(callback: (data: UserMessage) => void): void;
+    /**
+     * Send message to session
+     * @param body - Message body (can be MessageContent or raw content for agent messages)
+     */
+    sendClaudeSessionMessage(body: RawJSONLines): void;
+    /**
+     * Send a ping message to keep the connection alive
+     */
+    keepAlive(thinking: boolean): void;
+    /**
+     * Send session death message
+     */
+    sendSessionDeath(): void;
+    /**
+     * Send usage data to the server
+     */
+    sendUsageData(usage: Usage): void;
+    /**
+     * Update session metadata
+     * @param handler - Handler function that returns the updated metadata
+     */
+    updateMetadata(handler: (metadata: Metadata) => Metadata): void;
+    /**
+     * Update session agent state
+     * @param handler - Handler function that returns the updated agent state
+     */
+    updateAgentState(handler: (metadata: AgentState) => AgentState): void;
+    /**
+     * Set a custom RPC handler for a specific method with encrypted arguments and responses
+     * @param method - The method name to handle
+     * @param handler - The handler function to call when the method is invoked
+     */
+    setHandler<T = any, R = any>(method: string, handler: RpcHandler<T, R>): void;
+    /**
+     * Re-register all RPC handlers after reconnection
+     */
+    private reregisterHandlers;
+    /**
+     * Wait for socket buffer to flush
+     */
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface PushToken {
+    id: string;
+    token: string;
+    createdAt: number;
+    updatedAt: number;
+}
+declare class PushNotificationClient {
+    private readonly token;
+    private readonly baseUrl;
+    private readonly expo;
+    constructor(token: string, baseUrl?: string);
+    /**
+     * Fetch all push tokens for the authenticated user
+     */
+    fetchPushTokens(): Promise<PushToken[]>;
+    /**
+     * Send push notification via Expo Push API with retry
+     * @param messages - Array of push messages to send
+     */
+    sendPushNotifications(messages: ExpoPushMessage[]): Promise<void>;
+    /**
+     * Send a push notification to all registered devices for the user
+     * @param title - Notification title
+     * @param body - Notification body
+     * @param data - Additional data to send with the notification
+     */
+    sendToAllDevices(title: string, body: string, data?: Record<string, any>): Promise<void>;
+}
+
+declare class ApiClient {
+    private readonly token;
+    private readonly secret;
+    private readonly pushClient;
+    constructor(token: string, secret: Uint8Array);
+    /**
+     * Create a new session or load existing one with the given tag
+     */
+    getOrCreateSession(opts: {
+        tag: string;
+        metadata: Metadata;
+        state: AgentState | null;
+    }): Promise<Session>;
+    /**
+     * Start realtime session client
+     * @param id - Session ID
+     * @returns Session client
+     */
+    session(session: Session): ApiSessionClient;
+    /**
+     * Get push notification client
+     * @returns Push notification client
+     */
+    push(): PushNotificationClient;
+}
+
+/**
+ * Design decisions:
+ * - Logging should be done only through file for debugging, otherwise we might disturb the claude session when in interactive mode
+ * - Use info for logs that are useful to the user - this is our UI
+ * - File output location: ~/.handy/logs/<date time in local timezone>.log
+ */
+declare class Logger {
+    readonly logFilePathPromise: Promise<string>;
+    constructor(logFilePathPromise?: Promise<string>);
+    localTimezoneTimestamp(): string;
+    debug(message: string, ...args: unknown[]): void;
+    debugLargeJson(message: string, object: unknown, maxStringLength?: number, maxArrayLength?: number): void;
+    info(message: string, ...args: unknown[]): void;
+    infoDeveloper(message: string, ...args: unknown[]): void;
+    private logToConsole;
+    private logToFile;
+}
+declare let logger: Logger;
+declare function initLoggerWithGlobalConfiguration(): void;
+
+/**
+ * Global configuration for happy CLI
+ *
+ * Centralizes all configuration including environment variables and paths
+ * Environment files should be loaded using Node's --env-file flag
+ */
+declare class Configuration {
+    readonly serverUrl: string;
+    readonly happyDir: string;
+    readonly logsDir: string;
+    readonly settingsFile: string;
+    readonly privateKeyFile: string;
+    constructor(location: 'global' | 'local');
+}
+declare let configuration: Configuration;
+declare function initializeConfiguration(location: 'global' | 'local'): void;
+
+export { ApiClient, ApiSessionClient, type RawJSONLines, RawJSONLinesSchema, configuration, initLoggerWithGlobalConfiguration, initializeConfiguration, logger };