@liquidmetal-ai/raindrop 0.9.6 → 0.10.0

package/dist/commands/logs/tail.test.js

@@ -0,0 +1,366 @@
+import { create } from '@bufbuild/protobuf';
+import { QueryLogsResponseSchema, StreamLogsResponseSchema } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/riverjack_pb';
+import { expect, test, vi, describe, beforeEach, afterEach } from 'vitest';
+import Tail from './tail.js';
+// Mock valueOf function
+vi.mock('@liquidmetal-ai/drizzle/appify/build', () => ({
+    valueOf: (obj) => obj?.value || obj,
+}));
+// Mock the base command dependencies
+vi.mock('../../base-command.js', () => {
+    return {
+        BaseCommand: class {
+            static HIDDEN_FLAGS = {};
+            flags = {};
+            log = vi.fn();
+            error = vi.fn((msg, options) => {
+                if (options?.exit) {
+                    throw new Error(msg);
+                }
+            });
+            async loadManifest() {
+                return [{ name: { value: 'test-app' } }];
+            }
+            async loadConfig() {
+                return { versionId: 'test-version-123' };
+            }
+            async tenantRiverjackService() {
+                return {
+                    userId: 'test-user',
+                    organizationId: 'test-org',
+                    client: this.mockRiverjackClient,
+                };
+            }
+            mockRiverjackClient = {
+                queryLogs: vi.fn(),
+                streamLogs: vi.fn(),
+            };
+        }
+    };
+});
+// Mock the log helpers
+vi.mock('../../log-helpers.js', () => ({
+    displayTraceGroupedEvents: vi.fn(),
+}));
+describe('Tail command', () => {
+    let tail;
+    let mockQueryLogs;
+    let mockStreamLogs;
+    let logSpy;
+    beforeEach(() => {
+        tail = new Tail([], {});
+        logSpy = vi.spyOn(tail, 'log');
+        // Access the mock client through the instance
+        const mockClient = tail.mockRiverjackClient;
+        mockQueryLogs = mockClient.queryLogs;
+        mockStreamLogs = mockClient.streamLogs;
+        // Reset mocks
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('GNU tail behavior', () => {
+        test('default behavior: shows 10 logs and exits (no streaming)', async () => {
+            // Setup mock response
+            const mockEvents = [
+                { traceId: '1', message: 'log 1' },
+                { traceId: '2', message: 'log 2' },
+            ];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(2),
+                hasMore: false,
+            }));
+            // Set no flags (default behavior)
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+            };
+            await tail.run();
+            // Should query for 10 logs (default)
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 10,
+                organizationId: 'test-org',
+                userId: 'test-user',
+                applicationName: 'test-app',
+                applicationVersionId: 'test-version-123',
+            }));
+            // Should NOT start streaming
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            // Should show appropriate messages
+            expect(logSpy).toHaveBeenCalledWith('Using organization: test-org');
+            expect(logSpy).toHaveBeenCalledWith('Using user: test-user');
+            expect(logSpy).toHaveBeenCalledWith('Showing last 10 logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('📜 Showing last 2 log events:');
+            // Should NOT show streaming messages
+            expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Press Ctrl+C'));
+            expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Live stream starting'));
+        });
+        test('with -n flag: shows N logs and exits', async () => {
+            const mockEvents = Array(5).fill(null).map((_, i) => ({
+                traceId: `${i}`,
+                message: `log ${i}`,
+            }));
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(5),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 25,
+            };
+            await tail.run();
+            // Should query for 25 logs
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 25,
+            }));
+            // Should NOT stream
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            // Should show correct message
+            expect(logSpy).toHaveBeenCalledWith('Showing last 25 logs for test-app@test-version-123...');
+        });
+        test('with -f flag: shows 10 logs then streams', async () => {
+            const mockEvents = [{ traceId: '1', message: 'log 1' }];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(1),
+                hasMore: false,
+            }));
+            // Mock async generator for streaming
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                    message: 'Stream started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Should query for 10 logs (default)
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 10,
+            }));
+            // Should start streaming
+            expect(mockStreamLogs).toHaveBeenCalled();
+            // Should show appropriate messages
+            expect(logSpy).toHaveBeenCalledWith('Following logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('Press Ctrl+C to stop following\n');
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Live stream starting'));
+        });
+        test('with -n and -f flags: shows N logs then streams', async () => {
+            const mockEvents = Array(30).fill(null).map((_, i) => ({
+                traceId: `${i}`,
+                message: `log ${i}`,
+            }));
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(30),
+                hasMore: false,
+            }));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 30,
+                follow: true,
+            };
+            await tail.run();
+            // Should query for 30 logs
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                limit: 30,
+            }));
+            // Should start streaming
+            expect(mockStreamLogs).toHaveBeenCalled();
+            // Should show correct messages
+            expect(logSpy).toHaveBeenCalledWith('Following logs for test-app@test-version-123...');
+            expect(logSpy).toHaveBeenCalledWith('📜 Showing last 30 log events:');
+        });
+    });
+    describe('edge cases', () => {
+        test('handles no logs found gracefully', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 10,
+            };
+            await tail.run();
+            expect(logSpy).toHaveBeenCalledWith('ℹ️  No recent logs found in the last hour');
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+        });
+        test('handles query error gracefully when following', async () => {
+            mockQueryLogs.mockRejectedValue(new Error('Query failed'));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Should show error but continue to stream
+            expect(logSpy).toHaveBeenCalledWith('⚠️  Could not fetch recent logs: Query failed');
+            expect(logSpy).toHaveBeenCalledWith('🔴 Starting live stream anyway...');
+            expect(mockStreamLogs).toHaveBeenCalled();
+        });
+        test('handles query error gracefully when not following', async () => {
+            mockQueryLogs.mockRejectedValue(new Error('Query failed'));
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 10,
+            };
+            await tail.run();
+            // Should show error and exit
+            expect(logSpy).toHaveBeenCalledWith('⚠️  Could not fetch recent logs: Query failed');
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+        });
+        test('handles -n 0 correctly (no recent logs)', async () => {
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                lines: 0,
+            };
+            await tail.run();
+            // Should not query for logs when lines is 0
+            expect(mockQueryLogs).not.toHaveBeenCalled();
+            expect(mockStreamLogs).not.toHaveBeenCalled();
+            expect(logSpy).toHaveBeenCalledWith('Showing last 0 logs for test-app@test-version-123...');
+        });
+        test('handles JSON output format', async () => {
+            const mockEvents = [
+                { traceId: '1', message: 'log 1' },
+            ];
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: mockEvents,
+                totalCount: BigInt(1),
+                hasMore: false,
+            }));
+            tail.flags = {
+                application: 'test-app',
+                output: 'json',
+                lines: 1,
+            };
+            await tail.run();
+            // Should output JSON format
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('['));
+        });
+    });
+    describe('streaming behavior', () => {
+        test('handles different stream response types', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_started',
+                    message: 'Started',
+                    timestamp: new Date().toISOString(),
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'heartbeat',
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'events',
+                    events: [{ traceId: '1', message: 'streamed log' }],
+                });
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'stream_ended',
+                    message: 'Ended',
+                });
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            await tail.run();
+            // Check that different response types are handled
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Started streaming logs'));
+            expect(logSpy).toHaveBeenCalledWith('✅ Stream ended');
+        });
+        test('handles stream errors', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            // Mock error method to capture the error
+            const errorSpy = vi.spyOn(tail, 'error').mockImplementation((msg) => {
+                throw new Error(msg);
+            });
+            const mockStream = async function* () {
+                yield create(StreamLogsResponseSchema, {
+                    responseType: 'service_error',
+                    message: 'Stream connection failed',
+                });
+                throw new Error('Stream connection failed');
+            };
+            mockStreamLogs.mockReturnValue(mockStream());
+            tail.flags = {
+                application: 'test-app',
+                output: 'text',
+                follow: true,
+            };
+            // Should handle the error
+            await expect(tail.run()).rejects.toThrow('Failed to tail logs');
+            // Restore the mock
+            errorSpy.mockRestore();
+        });
+    });
+    describe('configuration', () => {
+        test('uses application from manifest when not provided', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                output: 'text',
+                // No application flag set
+            };
+            await tail.run();
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                applicationName: 'test-app', // From manifest
+            }));
+        });
+        test('uses provided application over manifest', async () => {
+            mockQueryLogs.mockResolvedValue(create(QueryLogsResponseSchema, {
+                events: [],
+                totalCount: BigInt(0),
+                hasMore: false,
+            }));
+            tail.flags = {
+                output: 'text',
+                application: 'custom-app',
+            };
+            await tail.run();
+            expect(mockQueryLogs).toHaveBeenCalledWith(expect.objectContaining({
+                applicationName: 'custom-app',
+            }));
+        });
+    });
+});

package/dist/commands/object/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/object/list.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW,CAAC,OAAO,UAAU,CAAC;IACpE,MAAM,CAAC,WAAW,SAA8B;IAEhD,MAAM,CAAC,QAAQ,WAUb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAgDV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqK3B"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/object/list.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW,CAAC,OAAO,UAAU,CAAC;IACpE,MAAM,CAAC,WAAW,SAA8B;IAEhD,MAAM,CAAC,QAAQ,WAUb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAgDV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA0P3B"}

package/dist/commands/object/list.js

@@ -193,25 +193,112 @@ List objects in my-bucket within my-app
             console.log('No objects found in bucket');
             return;
         }
+        // Get search agent service for status queries (used by all output formats)
+        const { client: searchAgent } = await this.searchAgentService();
+        // Query status for all objects using bulk API (significantly more efficient)
+        const statusMap = new Map();
+        try {
+            const bulkStatusResponse = await searchAgent.getDocumentStatusBulk({
+                userId,
+                organizationId,
+                bucketLocation,
+                objectIds: response.objects.map(obj => obj.key),
+            });
+            // Build a map of objectId -> formatted status
+            for (const docStatus of bulkStatusResponse.documents) {
+                let indexingStatus = 'unknown';
+                // Format status based on document state
+                if (docStatus.status === 'not_found') {
+                    indexingStatus = 'not started';
+                }
+                else if (docStatus.status === 'completed') {
+                    indexingStatus = 'completed';
+                }
+                else if (docStatus.status === 'failed') {
+                    const errorMsg = docStatus.errors.length > 0 ? ` (${docStatus.errors[0]})` : '';
+                    indexingStatus = `failed${errorMsg}`;
+                }
+                else if (docStatus.status === 'partial') {
+                    const errorMsg = docStatus.errors.length > 0 ? ` (${docStatus.errors[0]})` : '';
+                    indexingStatus = `partial${errorMsg}`;
+                }
+                else if (docStatus.status === 'ingesting') {
+                    const chunks = docStatus.ingest?.totalChunksCreated || 0;
+                    indexingStatus = `ingesting (${chunks} chunks)`;
+                }
+                else if (docStatus.status === 'processing') {
+                    // Show progress for most active stage
+                    const stages = [
+                        { name: 'embedding', info: docStatus.embedding },
+                        { name: 'vector index', info: docStatus.vectorIndex },
+                        { name: 'pii', info: docStatus.pii },
+                        { name: 'relationships', info: docStatus.relationships },
+                    ];
+                    // Find first stage with items remaining
+                    const activeStage = stages.find(s => s.info && s.info.itemsRemaining > 0);
+                    if (activeStage && activeStage.info) {
+                        const progress = activeStage.info.totalExpected - activeStage.info.itemsRemaining;
+                        const total = activeStage.info.totalExpected;
+                        indexingStatus = `processing ${activeStage.name} (${progress}/${total})`;
+                    }
+                    else {
+                        // No active stage found - check if stages have been initialized
+                        const hasInitializedStages = stages.some(s => s.info && s.info.totalExpected > 0);
+                        if (!hasInitializedStages) {
+                            // Stages not initialized yet - show ingest info
+                            const chunks = docStatus.ingest?.totalChunksCreated || 0;
+                            const queued = docStatus.ingest?.chunksQueued || 0;
+                            indexingStatus = `processing (${chunks} chunks created, ${queued} queued)`;
+                        }
+                        else {
+                            // Stages initialized but all complete - shouldn't happen in 'processing' state
+                            indexingStatus = 'processing';
+                        }
+                    }
+                }
+                else {
+                    indexingStatus = docStatus.status;
+                }
+                statusMap.set(docStatus.objectId, indexingStatus);
+            }
+        }
+        catch (error) {
+            // If bulk query fails, fall back to marking all as unknown
+            console.error('Failed to fetch bulk status:', error);
+        }
+        // Attach status to each object
+        const objectsWithStatus = response.objects.map(obj => ({
+            ...obj,
+            indexingStatus: statusMap.get(obj.key) || 'unknown',
+        }));
         switch (this.flags.output) {
-            case 'json':
-                console.log(toJsonString(ListObjectsResponseSchema, response, { prettySpaces: 2 }));
+            case 'json': {
+                // Create enhanced JSON response with indexing status
+                const jsonResponse = JSON.parse(toJsonString(ListObjectsResponseSchema, response));
+                jsonResponse.objects = objectsWithStatus.map((obj, index) => ({
+                    ...jsonResponse.objects[index],
+                    indexingStatus: obj.indexingStatus,
+                }));
+                console.log(JSON.stringify(jsonResponse, null, 2));
                 break;
+            }
             case 'table':
-                console.table(response.objects.map((obj) => ({
+                console.table(objectsWithStatus.map((obj) => ({
                     key: obj.key,
                     size: obj.size,
                     contentType: obj.contentType,
                     lastModified: obj.lastModified ? timestampDate(obj.lastModified).toUTCString() : 'N/A',
+                    indexing: obj.indexingStatus,
                 })));
                 break;
             default:
-                for (const obj of response.objects) {
+                for (const obj of objectsWithStatus) {
                     const lastModified = obj.lastModified ? timestampDate(obj.lastModified).toUTCString() : 'N/A';
                     console.log(`Key: ${obj.key}`);
                     console.log(`  Size: ${obj.size} bytes`);
                     console.log(`  Content-Type: ${obj.contentType || 'N/A'}`);
                     console.log(`  Last Modified: ${lastModified}`);
+                    console.log(`  Indexing: ${obj.indexingStatus}`);
                     console.log('---');
                 }
         }

package/dist/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../src/config.test.ts"],"names":[],"mappings":""}

package/dist/config.test.js

@@ -0,0 +1,27 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import { loadConfig, saveConfig } from './config.js';
+test('loading missing config returns default/base config', async () => {
+    const configPath = '/tmp/this-never-exists-config.json';
+    const config = await loadConfig(configPath);
+    expect(config).toEqual({
+        versionId: undefined,
+        sandbox: false,
+    });
+});
+test('save/load config', async () => {
+    // Make a temp directory and write a config file to it.
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'config-test'));
+    const configPath = path.join(tempDir, 'config.json');
+    await saveConfig(configPath, {
+        versionId: 'test-version-id',
+        sandbox: false,
+    });
+    const config = await loadConfig(configPath);
+    expect(config).toEqual({
+        versionId: 'test-version-id',
+        sandbox: false,
+    });
+});

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,56 @@
+import { expect, test } from 'vitest';
+import semver from 'semver';
+// Import the function for testing (we need to export it first)
+// For now, we'll test the logic by creating a local version
+function shouldUpdateCli(cliVersion, serverVersion) {
+    try {
+        // Use tilde range (~) - allows patch-level changes but requires same major.minor
+        const clientSatisfies = semver.satisfies(cliVersion, `~${serverVersion}`);
+        return !clientSatisfies;
+    }
+    catch {
+        // If version parsing fails, fall back to simple comparison
+        try {
+            return semver.lt(cliVersion, serverVersion);
+        }
+        catch {
+            // If all else fails, assume update is needed
+            return true;
+        }
+    }
+}
+test('shouldUpdateCli - same major.minor, CLI patch higher', () => {
+    expect(shouldUpdateCli('1.2.5', '1.2.3')).toBe(false);
+});
+test('shouldUpdateCli - same major.minor, server patch higher', () => {
+    expect(shouldUpdateCli('1.2.3', '1.2.5')).toBe(true);
+});
+test('shouldUpdateCli - same major.minor.patch', () => {
+    expect(shouldUpdateCli('1.2.3', '1.2.3')).toBe(false);
+});
+test('shouldUpdateCli - different major versions, server higher', () => {
+    expect(shouldUpdateCli('1.2.3', '2.0.0')).toBe(true);
+});
+test('shouldUpdateCli - different major versions, CLI higher', () => {
+    expect(shouldUpdateCli('2.0.0', '1.5.10')).toBe(true);
+});
+test('shouldUpdateCli - different minor versions, server higher', () => {
+    expect(shouldUpdateCli('1.2.3', '1.5.0')).toBe(true);
+});
+test('shouldUpdateCli - different minor versions, CLI higher', () => {
+    expect(shouldUpdateCli('1.5.0', '1.2.10')).toBe(true);
+});
+test('shouldUpdateCli - tilde range compatibility', () => {
+    // Within tilde range - should not require update
+    expect(shouldUpdateCli('1.2.5', '1.2.3')).toBe(false); // CLI 1.2.5 satisfies ~1.2.3 (>=1.2.3 <1.3.0)
+    expect(shouldUpdateCli('1.2.3', '1.2.5')).toBe(true); // CLI 1.2.3 does NOT satisfy ~1.2.5 (>=1.2.5 <1.3.0)
+    expect(shouldUpdateCli('1.2.3', '1.2.3')).toBe(false); // Same version
+    // Outside tilde range - should require update
+    expect(shouldUpdateCli('1.2.3', '1.3.0')).toBe(true); // Different minor
+    expect(shouldUpdateCli('1.2.3', '2.0.0')).toBe(true); // Different major
+});
+test('shouldUpdateCli - invalid version strings', () => {
+    expect(shouldUpdateCli('invalid', '1.2.3')).toBe(true);
+    expect(shouldUpdateCli('1.2.3', 'invalid')).toBe(true);
+    expect(shouldUpdateCli('invalid', 'invalid')).toBe(true);
+});