@forgehive/hive-sdk 0.0.3 → 0.1.0

package/dist/index.d.ts

@@ -1,14 +1,15 @@
 export interface Metadata {
     [key: string]: string;
 }
-export interface LogItemInput {
-    input: unknown;
-    output?: unknown;
-    error?: unknown;
-    boundaries?: unknown;
+export interface ExecutionRecord<InputType = unknown, OutputType = unknown, B = unknown> {
+    input: InputType;
+    output?: OutputType;
+    error?: string;
+    boundaries?: B;
+    taskName?: string;
     metadata?: Metadata;
+    type?: 'success' | 'error' | 'pending';
 }
-export type LogItem = LogItemInput;
 export interface HiveLogClientConfig {
     projectName: string;
     apiKey?: string;
@@ -20,17 +21,7 @@ export interface LogApiResponse {
     uuid: string;
     taskName: string;
     projectName: string;
-    logItem: {
-        input: unknown;
-        output?: unknown;
-        error?: unknown;
-        boundaries?: Record<string, Array<{
-            input: unknown;
-            output: unknown;
-            error: unknown;
-        }>>;
-        metadata?: Metadata;
-    };
+    logItem: ExecutionRecord;
     replayFrom?: string;
     createdAt: string;
 }
@@ -56,11 +47,32 @@ export declare class HiveLogClient {
     constructor(config: HiveLogClientConfig);
     isActive(): boolean;
     private mergeMetadata;
-    sendLog<T extends {
-        input: unknown;
-        metadata?: Metadata;
-    }>(taskName: string, logItem: T, metadata?: Metadata): Promise<'success' | 'error' | 'silent'>;
+    sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent'>;
+    getListener(): (record: ExecutionRecord) => Promise<void>;
     getLog(taskName: string, uuid: string): Promise<LogApiResult | null>;
     setQuality(taskName: string, uuid: string, quality: Quality): Promise<boolean>;
 }
 export declare const createHiveLogClient: (config: HiveLogClientConfig) => HiveLogClient;
+export interface HiveClientConfig {
+    projectUuid: string;
+    apiKey?: string;
+    apiSecret?: string;
+    host?: string;
+}
+export interface InvokeResponse {
+    responsePayload: unknown;
+}
+export interface InvokeError {
+    error: string;
+}
+export type InvokeResult = InvokeResponse | InvokeError;
+export declare function isInvokeError(response: unknown): response is InvokeError;
+export declare class HiveClient {
+    private apiKey;
+    private apiSecret;
+    private host;
+    private projectUuid;
+    constructor(config: HiveClientConfig);
+    invoke(taskName: string, payload: unknown): Promise<InvokeResult | null>;
+}
+export declare const createHiveClient: (config: HiveClientConfig) => HiveClient;

package/dist/index.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHiveLogClient = exports.HiveLogClient = void 0;
+exports.createHiveClient = exports.HiveClient = exports.createHiveLogClient = exports.HiveLogClient = void 0;
 exports.isApiError = isApiError;
+exports.isInvokeError = isInvokeError;
 const axios_1 = __importDefault(require("axios"));
 const debug_1 = __importDefault(require("debug"));
 const log = (0, debug_1.default)('hive-sdk');
@@ -37,12 +38,12 @@ class HiveLogClient {
     isActive() {
         return this.isInitialized;
     }
-    mergeMetadata(logItem, sendLogMetadata) {
+    mergeMetadata(record, sendLogMetadata) {
         // Start with base metadata from client
         let finalMetadata = { ...this.baseMetadata };
-        // Merge with logItem metadata if it exists
-        if (logItem.metadata) {
-            finalMetadata = { ...finalMetadata, ...logItem.metadata };
+        // Merge with record metadata if it exists
+        if (record.metadata) {
+            finalMetadata = { ...finalMetadata, ...record.metadata };
         }
         // Merge with sendLog metadata (highest priority)
         if (sendLogMetadata) {
@@ -50,7 +51,9 @@ class HiveLogClient {
         }
         return finalMetadata;
     }
-    async sendLog(taskName, logItem, metadata) {
+    async sendLog(record, metadata) {
+        // Extract taskName from record
+        const taskName = record.taskName || 'unknown-task';
         if (!this.isInitialized) {
             log('Silent mode: Skipping sendLog for task "%s" - client not initialized', taskName);
             return 'silent';
@@ -59,17 +62,18 @@ class HiveLogClient {
             const logsUrl = `${this.host}/api/tasks/log-ingest`;
             log('Sending log for task "%s" to %s', taskName, logsUrl);
             const authToken = `${this.apiKey}:${this.apiSecret}`;
-            // Merge metadata with priority: sendLog > logItem > client
-            const finalMetadata = this.mergeMetadata(logItem, metadata);
-            // Create enhanced logItem with merged metadata
-            const enhancedLogItem = {
-                ...logItem,
+            // Merge metadata with priority: sendLog > record.metadata > client
+            const finalMetadata = this.mergeMetadata(record, metadata);
+            // Create logItem with merged metadata
+            const logItem = {
+                ...record,
+                taskName,
                 metadata: finalMetadata
             };
             await axios_1.default.post(logsUrl, {
                 projectName: this.projectName,
                 taskName,
-                logItem: JSON.stringify(enhancedLogItem)
+                logItem: JSON.stringify(logItem)
             }, {
                 headers: {
                     Authorization: `Bearer ${authToken}`,
@@ -85,6 +89,11 @@ class HiveLogClient {
             return 'error';
         }
     }
+    getListener() {
+        return async (record) => {
+            await this.sendLog(record);
+        };
+    }
     async getLog(taskName, uuid) {
         if (!this.isInitialized) {
             log('Error: getLog for task "%s" with uuid "%s" - missing credentials', taskName, uuid);
@@ -142,3 +151,54 @@ const createHiveLogClient = (config) => {
     return new HiveLogClient(config);
 };
 exports.createHiveLogClient = createHiveLogClient;
+// Type guard to check if invoke response is an error
+function isInvokeError(response) {
+    return response !== null && typeof response === 'object' && 'error' in response;
+}
+class HiveClient {
+    constructor(config) {
+        const apiKey = config.apiKey || process.env.HIVE_API_KEY;
+        const apiSecret = config.apiSecret || process.env.HIVE_API_SECRET;
+        const host = config.host || process.env.HIVE_HOST || 'https://forgehive.dev';
+        if (!apiKey || !apiSecret) {
+            throw new Error('Missing Hive API credentials. Please provide apiKey and apiSecret, or set HIVE_API_KEY and HIVE_API_SECRET environment variables. Get them at https://forgehive.dev');
+        }
+        this.projectUuid = config.projectUuid;
+        this.host = host;
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+        log('HiveClient initialized for project "%s" with host "%s"', config.projectUuid, host);
+    }
+    async invoke(taskName, payload) {
+        try {
+            const invokeUrl = `${this.host}/api/project/${this.projectUuid}/task/${taskName}/invoke`;
+            log('Invoking task "%s" at %s', taskName, invokeUrl);
+            const authToken = `${this.apiKey}:${this.apiSecret}`;
+            const response = await axios_1.default.post(invokeUrl, {
+                payload
+            }, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            log('Success: Invoked task "%s"', taskName);
+            return response.data;
+        }
+        catch (e) {
+            const error = e;
+            log('Error: Failed to invoke task "%s": %s', taskName, error.message);
+            // Check if it's an axios error with response data
+            if (axios_1.default.isAxiosError(error) && error.response?.data) {
+                return error.response.data;
+            }
+            return { error: error.message };
+        }
+    }
+}
+exports.HiveClient = HiveClient;
+const createHiveClient = (config) => {
+    log('Creating HiveClient for project "%s"', config.projectUuid);
+    return new HiveClient(config);
+};
+exports.createHiveClient = createHiveClient;

package/dist/test/getLog.test.js

@@ -31,7 +31,7 @@ describe('HiveLogClient getLog', () => {
                 logItem: {
                     input: { userId: 123, action: 'login' },
                     output: { success: true, sessionId: 'abc123' },
-                    error: null,
+                    error: undefined,
                     boundaries: {
                         database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
                     }

package/dist/test/index.test.js

@@ -82,7 +82,14 @@ describe('Hive SDK', () => {
             silentClient = new index_1.HiveLogClient({ projectName: 'silent-project' });
         });
         it('should return "silent" for sendLog in silent mode', async () => {
-            const result = await silentClient.sendLog('test-task', { input: 'test' });
+            const executionRecord = {
+                input: { test: 'value' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await silentClient.sendLog(executionRecord);
             expect(result).toBe('silent');
         });
         it('should throw error for getLog in silent mode', async () => {

package/dist/test/metadata.test.js

@@ -67,8 +67,15 @@ describe('HiveLogClient Metadata', () => {
         });
         it('should send log without metadata parameter', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
-            const logItem = { input: 'test-input', output: 'test-output' };
-            const result = await client.sendLog('test-task', logItem);
+            const executionRecord = {
+                input: 'test-input',
+                output: 'test-output',
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLog(executionRecord);
             expect(result).toBe('success');
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -76,6 +83,9 @@ describe('HiveLogClient Metadata', () => {
                 logItem: JSON.stringify({
                     input: 'test-input',
                     output: 'test-output',
+                    taskName: 'test-task',
+                    type: 'success',
+                    boundaries: {},
                     metadata: {}
                 })
             }, {
@@ -87,12 +97,19 @@ describe('HiveLogClient Metadata', () => {
         });
         it('should send log with metadata parameter', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
-            const logItem = { input: 'test-input', output: 'test-output' };
+            const executionRecord = {
+                input: 'test-input',
+                output: 'test-output',
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
             const metadata = {
                 requestId: 'req-123',
                 userId: 'user-456'
             };
-            const result = await client.sendLog('test-task', logItem, metadata);
+            const result = await client.sendLog(executionRecord, metadata);
             expect(result).toBe('success');
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -100,6 +117,9 @@ describe('HiveLogClient Metadata', () => {
                 logItem: JSON.stringify({
                     input: 'test-input',
                     output: 'test-output',
+                    taskName: 'test-task',
+                    type: 'success',
+                    boundaries: {},
                     metadata: {
                         requestId: 'req-123',
                         userId: 'user-456'
@@ -115,13 +135,16 @@ describe('HiveLogClient Metadata', () => {
         it('should handle logItem with only input property', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const metadata = { type: 'minimal' };
-            const result = await client.sendLog('test-task', { input: 'simple input' }, metadata);
+            const result = await client.sendLog({ input: 'simple input', taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, metadata);
             expect(result).toBe('success');
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
                 taskName: 'test-task',
                 logItem: JSON.stringify({
                     input: 'simple input',
+                    taskName: 'test-task',
+                    type: 'success',
+                    boundaries: {},
                     metadata: { type: 'minimal' }
                 })
             }, expect.any(Object));
@@ -129,13 +152,16 @@ describe('HiveLogClient Metadata', () => {
         it('should handle logItem with null input values', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const metadata = { type: 'null-test' };
-            const result = await client.sendLog('test-task', { input: null }, metadata);
+            const result = await client.sendLog({ input: null, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, metadata);
             expect(result).toBe('success');
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
                 taskName: 'test-task',
                 logItem: JSON.stringify({
                     input: null,
+                    taskName: 'test-task',
+                    type: 'success',
+                    boundaries: {},
                     metadata: { type: 'null-test' }
                 })
             }, expect.any(Object));
@@ -150,9 +176,12 @@ describe('HiveLogClient Metadata', () => {
             };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
             const logItem = { input: 'test' };
-            await client.sendLog('test-task', logItem);
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} });
             const expectedLogItem = {
                 input: 'test',
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
                 metadata: {
                     environment: 'production',
                     version: '1.0.0'
@@ -178,14 +207,17 @@ describe('HiveLogClient Metadata', () => {
                     version: '1.1.0' // This should override base version
                 }
             };
-            await client.sendLog('test-task', logItem);
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} });
             const expectedLogItem = {
                 input: 'test',
                 metadata: {
                     environment: 'production', // from base
                     version: '1.1.0', // from logItem (overrides base)
                     sessionId: 'session-123' // from logItem
-                }
+                },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {}
             };
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -214,7 +246,7 @@ describe('HiveLogClient Metadata', () => {
                 version: '1.2.0',
                 priority: 'sendLog'
             };
-            await client.sendLog('test-task', logItem, sendLogMetadata);
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, sendLogMetadata);
             const expectedLogItem = {
                 input: 'test',
                 metadata: {
@@ -223,7 +255,10 @@ describe('HiveLogClient Metadata', () => {
                     priority: 'sendLog', // from sendLog (highest priority)
                     sessionId: 'session-123', // from logItem
                     requestId: 'req-456' // from sendLog
-                }
+                },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {}
             };
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -254,7 +289,7 @@ describe('HiveLogClient Metadata', () => {
                 userId: 'user-123',
                 version: '1.2.0' // overrides both base and logItem
             };
-            await client.sendLog('search-task', logItem, sendLogMetadata);
+            await client.sendLog({ ...logItem, taskName: 'search-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, sendLogMetadata);
             const expectedLogItem = {
                 input: { query: 'search' },
                 output: { results: [] },
@@ -267,7 +302,10 @@ describe('HiveLogClient Metadata', () => {
                     processingTime: '250', // from logItem
                     requestId: 'req-789', // from sendLog
                     userId: 'user-123' // from sendLog
-                }
+                },
+                taskName: 'search-task',
+                type: 'success',
+                boundaries: {}
             };
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -285,9 +323,12 @@ describe('HiveLogClient Metadata', () => {
                 input: 'test'
                 // No metadata property
             };
-            await client.sendLog('test-task', logItem);
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} });
             const expectedLogItem = {
                 input: 'test',
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
                 metadata: {
                     environment: 'test' // Only base metadata should be used
                 }
@@ -306,12 +347,15 @@ describe('HiveLogClient Metadata', () => {
                 input: 'test',
                 metadata: undefined
             };
-            await client.sendLog('test-task', logItem);
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} });
             const expectedLogItem = {
                 input: 'test',
                 metadata: {
                     environment: 'test' // Only base metadata should be used
-                }
+                },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {}
             };
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -323,10 +367,13 @@ describe('HiveLogClient Metadata', () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: {} });
             const logItem = { input: 'test', metadata: {} };
-            await client.sendLog('test-task', logItem, {});
+            await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, {});
             const expectedLogItem = {
                 input: 'test',
-                metadata: {} // All empty metadata objects result in empty final metadata
+                metadata: {}, // All empty metadata objects result in empty final metadata
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {}
             };
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
@@ -337,7 +384,7 @@ describe('HiveLogClient Metadata', () => {
         it('should work in silent mode with metadata', async () => {
             const baseMetadata = { environment: 'test' };
             const silentClient = new index_1.HiveLogClient({ projectName: 'silent-project', metadata: baseMetadata });
-            const result = await silentClient.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' });
+            const result = await silentClient.sendLog({ input: 'test', taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, { requestId: 'req-123' });
             expect(result).toBe('silent');
             expect(mockedAxios.post).not.toHaveBeenCalled();
         });
@@ -345,7 +392,7 @@ describe('HiveLogClient Metadata', () => {
             mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
             const baseMetadata = { environment: 'test' };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
-            const result = await client.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' });
+            const result = await client.sendLog({ input: 'test', taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, { requestId: 'req-123' });
             expect(result).toBe('error');
         });
     });