@enclave-vm/react 0.0.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@enclave-vm/react",
+  "version": "0.0.1",
+  "description": "React hooks and components for the EnclaveJS streaming runtime",
+  "author": "AgentFront <info@agentfront.dev>",
+  "homepage": "https://github.com/agentfront/enclave",
+  "license": "Apache-2.0",
+  "keywords": [
+    "enclavejs",
+    "enclave",
+    "react",
+    "hooks",
+    "streaming",
+    "runtime"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/enclave.git"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/enclave/issues"
+  },
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    }
+  },
+  "dependencies": {
+    "@enclave-vm/client": "0.0.1"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0"
+  },
+  "type": "commonjs"
+}

package/src/EnclaveProvider.d.ts

@@ -0,0 +1,60 @@
+/**
+ * EnclaveProvider
+ *
+ * React context provider for the EnclaveJS client.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import { EnclaveClient } from '@enclave-vm/client';
+import type { EnclaveProviderProps, EnclaveContextValue } from './types.js';
+/**
+ * React context for the Enclave client
+ */
+declare const EnclaveContext: React.Context<EnclaveContextValue | null>;
+/**
+ * EnclaveProvider component
+ *
+ * Provides the EnclaveClient to child components via React context.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <EnclaveProvider config={{ baseUrl: 'https://api.example.com' }}>
+ *       <MyComponent />
+ *     </EnclaveProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function EnclaveProvider({ config, client: providedClient, children, }: EnclaveProviderProps): React.ReactElement;
+/**
+ * useEnclaveContext hook
+ *
+ * Access the Enclave context directly. Throws if used outside EnclaveProvider.
+ *
+ * @internal
+ */
+export declare function useEnclaveContext(): EnclaveContextValue;
+/**
+ * useEnclaveClient hook
+ *
+ * Get the EnclaveClient instance from context.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const client = useEnclaveClient();
+ *
+ *   const handleClick = async () => {
+ *     const result = await client.execute('return 1 + 1');
+ *     console.log(result.value);
+ *   };
+ *
+ *   return <button onClick={handleClick}>Execute</button>;
+ * }
+ * ```
+ */
+export declare function useEnclaveClient(): EnclaveClient;
+export { EnclaveContext };

package/src/EnclaveProvider.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnclaveContext = void 0;
+exports.EnclaveProvider = EnclaveProvider;
+exports.useEnclaveContext = useEnclaveContext;
+exports.useEnclaveClient = useEnclaveClient;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * EnclaveProvider
+ *
+ * React context provider for the EnclaveJS client.
+ *
+ * @packageDocumentation
+ */
+const react_1 = require("react");
+const client_1 = require("@enclave-vm/client");
+/**
+ * React context for the Enclave client
+ */
+const EnclaveContext = (0, react_1.createContext)(null);
+exports.EnclaveContext = EnclaveContext;
+/**
+ * EnclaveProvider component
+ *
+ * Provides the EnclaveClient to child components via React context.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <EnclaveProvider config={{ baseUrl: 'https://api.example.com' }}>
+ *       <MyComponent />
+ *     </EnclaveProvider>
+ *   );
+ * }
+ * ```
+ */
+function EnclaveProvider({ config, client: providedClient, children, }) {
+    // Use ref to ensure client is only created once
+    const clientRef = (0, react_1.useRef)(null);
+    // Create or use provided client
+    const client = (0, react_1.useMemo)(() => {
+        if (providedClient) {
+            return providedClient;
+        }
+        // Create new client if not already created
+        if (!clientRef.current) {
+            clientRef.current = new client_1.EnclaveClient(config);
+        }
+        return clientRef.current;
+    }, [providedClient, config]);
+    // Memoize context value
+    const contextValue = (0, react_1.useMemo)(() => ({
+        client,
+        config,
+    }), [client, config]);
+    return (0, jsx_runtime_1.jsx)(EnclaveContext.Provider, { value: contextValue, children: children });
+}
+/**
+ * useEnclaveContext hook
+ *
+ * Access the Enclave context directly. Throws if used outside EnclaveProvider.
+ *
+ * @internal
+ */
+function useEnclaveContext() {
+    const context = (0, react_1.useContext)(EnclaveContext);
+    if (!context) {
+        throw new Error('useEnclaveContext must be used within an EnclaveProvider. ' +
+            'Wrap your component tree with <EnclaveProvider config={{...}}>.');
+    }
+    return context;
+}
+/**
+ * useEnclaveClient hook
+ *
+ * Get the EnclaveClient instance from context.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const client = useEnclaveClient();
+ *
+ *   const handleClick = async () => {
+ *     const result = await client.execute('return 1 + 1');
+ *     console.log(result.value);
+ *   };
+ *
+ *   return <button onClick={handleClick}>Execute</button>;
+ * }
+ * ```
+ */
+function useEnclaveClient() {
+    const { client } = useEnclaveContext();
+    return client;
+}
+//# sourceMappingURL=EnclaveProvider.js.map

package/src/EnclaveProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnclaveProvider.js","sourceRoot":"","sources":["../../src/EnclaveProvider.tsx"],"names":[],"mappings":";;;AAiCA,0CAgCC;AASD,8CAWC;AAqBD,4CAGC;;AA7GD;;;;;;GAMG;AAEH,iCAA0E;AAC1E,+CAAmD;AAGnD;;GAEG;AACH,MAAM,cAAc,GAAG,IAAA,qBAAa,EAA6B,IAAI,CAAC,CAAC;AAgG9D,wCAAc;AA9FvB;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,MAAM,EAAE,cAAc,EACtB,QAAQ,GACa;IACrB,gDAAgD;IAChD,MAAM,SAAS,GAAG,IAAA,cAAM,EAAuB,IAAI,CAAC,CAAC;IAErD,gCAAgC;IAChC,MAAM,MAAM,GAAG,IAAA,eAAO,EAAC,GAAG,EAAE;QAC1B,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,cAAc,CAAC;QACxB,CAAC;QAED,2CAA2C;QAC3C,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YACvB,SAAS,CAAC,OAAO,GAAG,IAAI,sBAAa,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,SAAS,CAAC,OAAO,CAAC;IAC3B,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;IAE7B,wBAAwB;IACxB,MAAM,YAAY,GAAG,IAAA,eAAO,EAC1B,GAAG,EAAE,CAAC,CAAC;QACL,MAAM;QACN,MAAM;KACP,CAAC,EACF,CAAC,MAAM,EAAE,MAAM,CAAC,CACjB,CAAC;IAEF,OAAO,uBAAC,cAAc,CAAC,QAAQ,IAAC,KAAK,EAAE,YAAY,YAAG,QAAQ,GAA2B,CAAC;AAC5F,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,iBAAiB;IAC/B,MAAM,OAAO,GAAG,IAAA,kBAAU,EAAC,cAAc,CAAC,CAAC;IAE3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,4DAA4D;YAC1D,iEAAiE,CACpE,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,gBAAgB;IAC9B,MAAM,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAAC;IACvC,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * EnclaveProvider\n *\n * React context provider for the EnclaveJS client.\n *\n * @packageDocumentation\n */\n\nimport React, { createContext, useContext, useMemo, useRef } from 'react';\nimport { EnclaveClient } from '@enclave-vm/client';\nimport type { EnclaveProviderProps, EnclaveContextValue } from './types.js';\n\n/**\n * React context for the Enclave client\n */\nconst EnclaveContext = createContext<EnclaveContextValue | null>(null);\n\n/**\n * EnclaveProvider component\n *\n * Provides the EnclaveClient to child components via React context.\n *\n * @example\n * ```tsx\n * function App() {\n *   return (\n *     <EnclaveProvider config={{ baseUrl: 'https://api.example.com' }}>\n *       <MyComponent />\n *     </EnclaveProvider>\n *   );\n * }\n * ```\n */\nexport function EnclaveProvider({\n  config,\n  client: providedClient,\n  children,\n}: EnclaveProviderProps): React.ReactElement {\n  // Use ref to ensure client is only created once\n  const clientRef = useRef<EnclaveClient | null>(null);\n\n  // Create or use provided client\n  const client = useMemo(() => {\n    if (providedClient) {\n      return providedClient;\n    }\n\n    // Create new client if not already created\n    if (!clientRef.current) {\n      clientRef.current = new EnclaveClient(config);\n    }\n\n    return clientRef.current;\n  }, [providedClient, config]);\n\n  // Memoize context value\n  const contextValue = useMemo<EnclaveContextValue>(\n    () => ({\n      client,\n      config,\n    }),\n    [client, config],\n  );\n\n  return <EnclaveContext.Provider value={contextValue}>{children}</EnclaveContext.Provider>;\n}\n\n/**\n * useEnclaveContext hook\n *\n * Access the Enclave context directly. Throws if used outside EnclaveProvider.\n *\n * @internal\n */\nexport function useEnclaveContext(): EnclaveContextValue {\n  const context = useContext(EnclaveContext);\n\n  if (!context) {\n    throw new Error(\n      'useEnclaveContext must be used within an EnclaveProvider. ' +\n        'Wrap your component tree with <EnclaveProvider config={{...}}>.',\n    );\n  }\n\n  return context;\n}\n\n/**\n * useEnclaveClient hook\n *\n * Get the EnclaveClient instance from context.\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const client = useEnclaveClient();\n *\n *   const handleClick = async () => {\n *     const result = await client.execute('return 1 + 1');\n *     console.log(result.value);\n *   };\n *\n *   return <button onClick={handleClick}>Execute</button>;\n * }\n * ```\n */\nexport function useEnclaveClient(): EnclaveClient {\n  const { client } = useEnclaveContext();\n  return client;\n}\n\nexport { EnclaveContext };\n"]}

package/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @enclave-vm/react
+ *
+ * React hooks and components for the EnclaveJS streaming runtime.
+ *
+ * @packageDocumentation
+ */
+export { EnclaveProvider, useEnclaveClient, useEnclaveContext } from './EnclaveProvider.js';
+export { useEnclaveSession } from './useEnclaveSession.js';
+export type { SessionState, UseEnclaveSessionOptions, UseEnclaveSessionReturn, EnclaveProviderProps, EnclaveContextValue, } from './types.js';
+export type { EnclaveClient, EnclaveClientConfig, SessionResult, SessionHandle, StreamEvent, SessionId, } from '@enclave-vm/client';

package/src/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @enclave-vm/react
+ *
+ * React hooks and components for the EnclaveJS streaming runtime.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEnclaveSession = exports.useEnclaveContext = exports.useEnclaveClient = exports.EnclaveProvider = void 0;
+// Provider and context
+var EnclaveProvider_js_1 = require("./EnclaveProvider.js");
+Object.defineProperty(exports, "EnclaveProvider", { enumerable: true, get: function () { return EnclaveProvider_js_1.EnclaveProvider; } });
+Object.defineProperty(exports, "useEnclaveClient", { enumerable: true, get: function () { return EnclaveProvider_js_1.useEnclaveClient; } });
+Object.defineProperty(exports, "useEnclaveContext", { enumerable: true, get: function () { return EnclaveProvider_js_1.useEnclaveContext; } });
+// Hooks
+var useEnclaveSession_js_1 = require("./useEnclaveSession.js");
+Object.defineProperty(exports, "useEnclaveSession", { enumerable: true, get: function () { return useEnclaveSession_js_1.useEnclaveSession; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,uBAAuB;AACvB,2DAA4F;AAAnF,qHAAA,eAAe,OAAA;AAAE,sHAAA,gBAAgB,OAAA;AAAE,uHAAA,iBAAiB,OAAA;AAE7D,QAAQ;AACR,+DAA2D;AAAlD,yHAAA,iBAAiB,OAAA","sourcesContent":["/**\n * @enclave-vm/react\n *\n * React hooks and components for the EnclaveJS streaming runtime.\n *\n * @packageDocumentation\n */\n\n// Provider and context\nexport { EnclaveProvider, useEnclaveClient, useEnclaveContext } from './EnclaveProvider.js';\n\n// Hooks\nexport { useEnclaveSession } from './useEnclaveSession.js';\n\n// Types\nexport type {\n  SessionState,\n  UseEnclaveSessionOptions,\n  UseEnclaveSessionReturn,\n  EnclaveProviderProps,\n  EnclaveContextValue,\n} from './types.js';\n\n// Re-export commonly used types from @enclave-vm/client\nexport type {\n  EnclaveClient,\n  EnclaveClientConfig,\n  SessionResult,\n  SessionHandle,\n  StreamEvent,\n  SessionId,\n} from '@enclave-vm/client';\n"]}

package/src/test-setup.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Test setup for React Testing Library
+ */
+import '@testing-library/jest-dom';

package/src/test-setup.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Test setup for React Testing Library
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@testing-library/jest-dom");
+//# sourceMappingURL=test-setup.js.map

package/src/test-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.js","sourceRoot":"","sources":["../../src/test-setup.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAEH,qCAAmC","sourcesContent":["/**\n * Test setup for React Testing Library\n */\n\nimport '@testing-library/jest-dom';\n"]}

package/src/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * React Types
+ *
+ * Types for the EnclaveJS React hooks and components.
+ *
+ * @packageDocumentation
+ */
+import type { EnclaveClient, EnclaveClientConfig, SessionResult, StreamEvent, SessionId } from '@enclave-vm/client';
+/**
+ * Session state enum
+ */
+export type SessionState = 'idle' | 'running' | 'completed' | 'error' | 'cancelled';
+/**
+ * useEnclaveSession hook options
+ */
+export interface UseEnclaveSessionOptions {
+    /**
+     * Custom session ID (generated if not provided)
+     */
+    sessionId?: SessionId;
+    /**
+     * Session timeout in milliseconds
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum number of tool calls
+     */
+    maxToolCalls?: number;
+    /**
+     * Heartbeat interval in milliseconds
+     */
+    heartbeatIntervalMs?: number;
+    /**
+     * Callback when session starts
+     */
+    onStart?: () => void;
+    /**
+     * Callback for stdout output
+     */
+    onStdout?: (chunk: string) => void;
+    /**
+     * Callback for log messages
+     */
+    onLog?: (level: string, message: string, data?: Record<string, unknown>) => void;
+    /**
+     * Callback for tool calls
+     */
+    onToolCall?: (callId: string, toolName: string, args: unknown) => void;
+    /**
+     * Callback when tool result is applied
+     */
+    onToolResultApplied?: (callId: string) => void;
+    /**
+     * Callback on completion
+     */
+    onComplete?: (result: SessionResult) => void;
+    /**
+     * Callback on error
+     */
+    onError?: (error: {
+        code?: string;
+        message: string;
+    }) => void;
+}
+/**
+ * useEnclaveSession hook return type
+ */
+export interface UseEnclaveSessionReturn<T = unknown> {
+    /**
+     * Execute code in the enclave
+     */
+    execute: (code: string) => Promise<SessionResult<T>>;
+    /**
+     * Cancel the current session
+     */
+    cancel: (reason?: string) => Promise<void>;
+    /**
+     * Current session state
+     */
+    state: SessionState;
+    /**
+     * Whether a session is currently running
+     */
+    isRunning: boolean;
+    /**
+     * Current session ID (if running)
+     */
+    sessionId: SessionId | null;
+    /**
+     * Result of the last execution (if completed)
+     */
+    result: SessionResult<T> | null;
+    /**
+     * Error from the last execution (if failed)
+     */
+    error: {
+        code?: string;
+        message: string;
+    } | null;
+    /**
+     * Stdout output accumulated during execution
+     */
+    stdout: string;
+    /**
+     * Events received during execution
+     */
+    events: StreamEvent[];
+    /**
+     * Reset the hook state
+     */
+    reset: () => void;
+}
+/**
+ * EnclaveProvider props
+ */
+export interface EnclaveProviderProps {
+    /**
+     * Client configuration
+     */
+    config: EnclaveClientConfig;
+    /**
+     * Pre-created client instance (alternative to config)
+     */
+    client?: EnclaveClient;
+    /**
+     * Children to render
+     */
+    children: React.ReactNode;
+}
+/**
+ * Enclave context value
+ */
+export interface EnclaveContextValue {
+    /**
+     * The EnclaveClient instance
+     */
+    client: EnclaveClient;
+    /**
+     * Client configuration
+     */
+    config: EnclaveClientConfig;
+}

package/src/types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * React Types
+ *
+ * Types for the EnclaveJS React hooks and components.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG","sourcesContent":["/**\n * React Types\n *\n * Types for the EnclaveJS React hooks and components.\n *\n * @packageDocumentation\n */\n\nimport type { EnclaveClient, EnclaveClientConfig, SessionResult, StreamEvent, SessionId } from '@enclave-vm/client';\n\n/**\n * Session state enum\n */\nexport type SessionState = 'idle' | 'running' | 'completed' | 'error' | 'cancelled';\n\n/**\n * useEnclaveSession hook options\n */\nexport interface UseEnclaveSessionOptions {\n  /**\n   * Custom session ID (generated if not provided)\n   */\n  sessionId?: SessionId;\n\n  /**\n   * Session timeout in milliseconds\n   */\n  timeoutMs?: number;\n\n  /**\n   * Maximum number of tool calls\n   */\n  maxToolCalls?: number;\n\n  /**\n   * Heartbeat interval in milliseconds\n   */\n  heartbeatIntervalMs?: number;\n\n  /**\n   * Callback when session starts\n   */\n  onStart?: () => void;\n\n  /**\n   * Callback for stdout output\n   */\n  onStdout?: (chunk: string) => void;\n\n  /**\n   * Callback for log messages\n   */\n  onLog?: (level: string, message: string, data?: Record<string, unknown>) => void;\n\n  /**\n   * Callback for tool calls\n   */\n  onToolCall?: (callId: string, toolName: string, args: unknown) => void;\n\n  /**\n   * Callback when tool result is applied\n   */\n  onToolResultApplied?: (callId: string) => void;\n\n  /**\n   * Callback on completion\n   */\n  onComplete?: (result: SessionResult) => void;\n\n  /**\n   * Callback on error\n   */\n  onError?: (error: { code?: string; message: string }) => void;\n}\n\n/**\n * useEnclaveSession hook return type\n */\nexport interface UseEnclaveSessionReturn<T = unknown> {\n  /**\n   * Execute code in the enclave\n   */\n  execute: (code: string) => Promise<SessionResult<T>>;\n\n  /**\n   * Cancel the current session\n   */\n  cancel: (reason?: string) => Promise<void>;\n\n  /**\n   * Current session state\n   */\n  state: SessionState;\n\n  /**\n   * Whether a session is currently running\n   */\n  isRunning: boolean;\n\n  /**\n   * Current session ID (if running)\n   */\n  sessionId: SessionId | null;\n\n  /**\n   * Result of the last execution (if completed)\n   */\n  result: SessionResult<T> | null;\n\n  /**\n   * Error from the last execution (if failed)\n   */\n  error: { code?: string; message: string } | null;\n\n  /**\n   * Stdout output accumulated during execution\n   */\n  stdout: string;\n\n  /**\n   * Events received during execution\n   */\n  events: StreamEvent[];\n\n  /**\n   * Reset the hook state\n   */\n  reset: () => void;\n}\n\n/**\n * EnclaveProvider props\n */\nexport interface EnclaveProviderProps {\n  /**\n   * Client configuration\n   */\n  config: EnclaveClientConfig;\n\n  /**\n   * Pre-created client instance (alternative to config)\n   */\n  client?: EnclaveClient;\n\n  /**\n   * Children to render\n   */\n  children: React.ReactNode;\n}\n\n/**\n * Enclave context value\n */\nexport interface EnclaveContextValue {\n  /**\n   * The EnclaveClient instance\n   */\n  client: EnclaveClient;\n\n  /**\n   * Client configuration\n   */\n  config: EnclaveClientConfig;\n}\n"]}

package/src/useEnclaveSession.d.ts

@@ -0,0 +1,38 @@
+/**
+ * useEnclaveSession Hook
+ *
+ * React hook for executing code in the EnclaveJS runtime with state management.
+ *
+ * @packageDocumentation
+ */
+import type { UseEnclaveSessionOptions, UseEnclaveSessionReturn } from './types.js';
+/**
+ * useEnclaveSession hook
+ *
+ * Provides a stateful interface for executing code in the Enclave runtime.
+ *
+ * @example
+ * ```tsx
+ * function Calculator() {
+ *   const { execute, isRunning, result, stdout } = useEnclaveSession({
+ *     onStdout: (chunk) => console.log(chunk),
+ *   });
+ *
+ *   const calculate = async () => {
+ *     const result = await execute('return 1 + 1');
+ *     console.log('Result:', result.value);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={calculate} disabled={isRunning}>
+ *         Calculate
+ *       </button>
+ *       {result && <p>Result: {JSON.stringify(result.value)}</p>}
+ *       <pre>{stdout}</pre>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useEnclaveSession<T = unknown>(options?: UseEnclaveSessionOptions): UseEnclaveSessionReturn<T>;

package/src/useEnclaveSession.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * useEnclaveSession Hook
+ *
+ * React hook for executing code in the EnclaveJS runtime with state management.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEnclaveSession = useEnclaveSession;
+const react_1 = require("react");
+const EnclaveProvider_js_1 = require("./EnclaveProvider.js");
+/**
+ * useEnclaveSession hook
+ *
+ * Provides a stateful interface for executing code in the Enclave runtime.
+ *
+ * @example
+ * ```tsx
+ * function Calculator() {
+ *   const { execute, isRunning, result, stdout } = useEnclaveSession({
+ *     onStdout: (chunk) => console.log(chunk),
+ *   });
+ *
+ *   const calculate = async () => {
+ *     const result = await execute('return 1 + 1');
+ *     console.log('Result:', result.value);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={calculate} disabled={isRunning}>
+ *         Calculate
+ *       </button>
+ *       {result && <p>Result: {JSON.stringify(result.value)}</p>}
+ *       <pre>{stdout}</pre>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+function useEnclaveSession(options = {}) {
+    const client = (0, EnclaveProvider_js_1.useEnclaveClient)();
+    // State
+    const [state, setState] = (0, react_1.useState)('idle');
+    const [sessionId, setSessionId] = (0, react_1.useState)(null);
+    const [result, setResult] = (0, react_1.useState)(null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [stdout, setStdout] = (0, react_1.useState)('');
+    const [events, setEvents] = (0, react_1.useState)([]);
+    // Refs for current session handle
+    const handleRef = (0, react_1.useRef)(null);
+    /**
+     * Reset the hook state
+     */
+    const reset = (0, react_1.useCallback)(() => {
+        setState('idle');
+        setSessionId(null);
+        setResult(null);
+        setError(null);
+        setStdout('');
+        setEvents([]);
+        handleRef.current = null;
+    }, []);
+    /**
+     * Execute code in the enclave
+     */
+    const execute = (0, react_1.useCallback)(async (code) => {
+        // Reset state for new execution
+        setState('running');
+        setResult(null);
+        setError(null);
+        setStdout('');
+        setEvents([]);
+        // Call onStart callback
+        options.onStart?.();
+        // Build limits from options
+        const limits = {};
+        if (options.timeoutMs !== undefined) {
+            limits.sessionTtlMs = options.timeoutMs;
+        }
+        if (options.maxToolCalls !== undefined) {
+            limits.maxToolCalls = options.maxToolCalls;
+        }
+        if (options.heartbeatIntervalMs !== undefined) {
+            limits.heartbeatIntervalMs = options.heartbeatIntervalMs;
+        }
+        // Start streaming execution
+        const handle = client.executeStream(code, {
+            sessionId: options.sessionId,
+            limits: Object.keys(limits).length > 0 ? limits : undefined,
+            onEvent: (event) => {
+                setEvents((prev) => [...prev, event]);
+            },
+            onStdout: (chunk) => {
+                setStdout((prev) => prev + chunk);
+                options.onStdout?.(chunk);
+            },
+            onLog: (level, message, data) => {
+                options.onLog?.(level, message, data);
+            },
+            onToolCall: (callId, toolName, args) => {
+                options.onToolCall?.(callId, toolName, args);
+            },
+            onToolResultApplied: (callId) => {
+                options.onToolResultApplied?.(callId);
+            },
+            onError: (code, message) => {
+                options.onError?.({ code, message });
+            },
+        });
+        handleRef.current = handle;
+        setSessionId(handle.sessionId);
+        try {
+            // Wait for completion
+            const sessionResult = (await handle.wait());
+            // Update state based on result
+            if (sessionResult.success) {
+                setState('completed');
+                setResult(sessionResult);
+            }
+            else if (sessionResult.error?.code === 'CANCELLED') {
+                setState('cancelled');
+                setResult(sessionResult);
+            }
+            else {
+                setState('error');
+                setResult(sessionResult);
+                setError(sessionResult.error ?? { message: 'Unknown error' });
+                options.onError?.(sessionResult.error ?? { message: 'Unknown error' });
+            }
+            // Call onComplete callback
+            options.onComplete?.(sessionResult);
+            return sessionResult;
+        }
+        catch (err) {
+            // Handle unexpected errors
+            const errorInfo = {
+                code: 'UNEXPECTED_ERROR',
+                message: err instanceof Error ? err.message : 'Unknown error',
+            };
+            setState('error');
+            setError(errorInfo);
+            options.onError?.(errorInfo);
+            // Return error result
+            const errorResult = {
+                success: false,
+                sessionId: handle.sessionId,
+                error: errorInfo,
+                events: handle.getEvents(),
+            };
+            setResult(errorResult);
+            options.onComplete?.(errorResult);
+            return errorResult;
+        }
+        finally {
+            handleRef.current = null;
+        }
+    }, [client, options]);
+    /**
+     * Cancel the current session
+     */
+    const cancel = (0, react_1.useCallback)(async (reason) => {
+        if (handleRef.current) {
+            await handleRef.current.cancel(reason);
+        }
+    }, []);
+    return {
+        execute,
+        cancel,
+        state,
+        isRunning: state === 'running',
+        sessionId,
+        result,
+        error,
+        stdout,
+        events,
+        reset,
+    };
+}
+//# sourceMappingURL=useEnclaveSession.js.map

package/src/useEnclaveSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnclaveSession.js","sourceRoot":"","sources":["../../src/useEnclaveSession.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * useEnclaveSession Hook\n *\n * React hook for executing code in the EnclaveJS runtime with state management.\n *\n * @packageDocumentation\n */\n\nimport { useState, useCallback, useRef } from 'react';\nimport type { SessionResult, SessionHandle, StreamEvent, SessionId } from '@enclave-vm/client';\nimport { useEnclaveClient } from './EnclaveProvider.js';\nimport type { SessionState, UseEnclaveSessionOptions, UseEnclaveSessionReturn } from './types.js';\n\n/**\n * useEnclaveSession hook\n *\n * Provides a stateful interface for executing code in the Enclave runtime.\n *\n * @example\n * ```tsx\n * function Calculator() {\n *   const { execute, isRunning, result, stdout } = useEnclaveSession({\n *     onStdout: (chunk) => console.log(chunk),\n *   });\n *\n *   const calculate = async () => {\n *     const result = await execute('return 1 + 1');\n *     console.log('Result:', result.value);\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={calculate} disabled={isRunning}>\n *         Calculate\n *       </button>\n *       {result && <p>Result: {JSON.stringify(result.value)}</p>}\n *       <pre>{stdout}</pre>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useEnclaveSession<T = unknown>(options: UseEnclaveSessionOptions = {}): UseEnclaveSessionReturn<T> {\n  const client = useEnclaveClient();\n\n  // State\n  const [state, setState] = useState<SessionState>('idle');\n  const [sessionId, setSessionId] = useState<SessionId | null>(null);\n  const [result, setResult] = useState<SessionResult<T> | null>(null);\n  const [error, setError] = useState<{ code?: string; message: string } | null>(null);\n  const [stdout, setStdout] = useState<string>('');\n  const [events, setEvents] = useState<StreamEvent[]>([]);\n\n  // Refs for current session handle\n  const handleRef = useRef<SessionHandle | null>(null);\n\n  /**\n   * Reset the hook state\n   */\n  const reset = useCallback(() => {\n    setState('idle');\n    setSessionId(null);\n    setResult(null);\n    setError(null);\n    setStdout('');\n    setEvents([]);\n    handleRef.current = null;\n  }, []);\n\n  /**\n   * Execute code in the enclave\n   */\n  const execute = useCallback(\n    async (code: string): Promise<SessionResult<T>> => {\n      // Reset state for new execution\n      setState('running');\n      setResult(null);\n      setError(null);\n      setStdout('');\n      setEvents([]);\n\n      // Call onStart callback\n      options.onStart?.();\n\n      // Build limits from options\n      const limits: Record<string, number> = {};\n      if (options.timeoutMs !== undefined) {\n        limits.sessionTtlMs = options.timeoutMs;\n      }\n      if (options.maxToolCalls !== undefined) {\n        limits.maxToolCalls = options.maxToolCalls;\n      }\n      if (options.heartbeatIntervalMs !== undefined) {\n        limits.heartbeatIntervalMs = options.heartbeatIntervalMs;\n      }\n\n      // Start streaming execution\n      const handle = client.executeStream(code, {\n        sessionId: options.sessionId,\n        limits: Object.keys(limits).length > 0 ? limits : undefined,\n        onEvent: (event) => {\n          setEvents((prev) => [...prev, event]);\n        },\n        onStdout: (chunk) => {\n          setStdout((prev) => prev + chunk);\n          options.onStdout?.(chunk);\n        },\n        onLog: (level, message, data) => {\n          options.onLog?.(level, message, data);\n        },\n        onToolCall: (callId, toolName, args) => {\n          options.onToolCall?.(callId, toolName, args);\n        },\n        onToolResultApplied: (callId) => {\n          options.onToolResultApplied?.(callId);\n        },\n        onError: (code, message) => {\n          options.onError?.({ code, message });\n        },\n      });\n\n      handleRef.current = handle;\n      setSessionId(handle.sessionId);\n\n      try {\n        // Wait for completion\n        const sessionResult = (await handle.wait()) as SessionResult<T>;\n\n        // Update state based on result\n        if (sessionResult.success) {\n          setState('completed');\n          setResult(sessionResult);\n        } else if (sessionResult.error?.code === 'CANCELLED') {\n          setState('cancelled');\n          setResult(sessionResult);\n        } else {\n          setState('error');\n          setResult(sessionResult);\n          setError(sessionResult.error ?? { message: 'Unknown error' });\n          options.onError?.(sessionResult.error ?? { message: 'Unknown error' });\n        }\n\n        // Call onComplete callback\n        options.onComplete?.(sessionResult);\n\n        return sessionResult;\n      } catch (err) {\n        // Handle unexpected errors\n        const errorInfo = {\n          code: 'UNEXPECTED_ERROR',\n          message: err instanceof Error ? err.message : 'Unknown error',\n        };\n\n        setState('error');\n        setError(errorInfo);\n        options.onError?.(errorInfo);\n\n        // Return error result\n        const errorResult: SessionResult<T> = {\n          success: false,\n          sessionId: handle.sessionId,\n          error: errorInfo,\n          events: handle.getEvents(),\n        };\n\n        setResult(errorResult);\n        options.onComplete?.(errorResult);\n\n        return errorResult;\n      } finally {\n        handleRef.current = null;\n      }\n    },\n    [client, options],\n  );\n\n  /**\n   * Cancel the current session\n   */\n  const cancel = useCallback(async (reason?: string): Promise<void> => {\n    if (handleRef.current) {\n      await handleRef.current.cancel(reason);\n    }\n  }, []);\n\n  return {\n    execute,\n    cancel,\n    state,\n    isRunning: state === 'running',\n    sessionId,\n    result,\n    error,\n    stdout,\n    events,\n    reset,\n  };\n}\n"]}