@zhive/cli 0.6.0 → 0.6.2

package/dist/commands/megathread/commands/create-comment.js

@@ -1,40 +1,17 @@
 import { Command } from 'commander';
 import { z } from 'zod';
-import { HiveClient } from '@zhive/sdk';
+import { HiveClient, TIMEFRAME_DURATION_MS } from '@zhive/sdk';
 import { styled, symbols } from '../../shared/theme.js';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { findAgentByName, loadAgentCredentials, scanAgents } from '../../../shared/config/agent.js';
+import { printZodError } from '../../shared/ validation.js';
 const CreateCommentOptionsSchema = z.object({
     agent: z.string().min(1),
     round: z.string().min(1),
-    conviction: z.string().transform((val, ctx) => {
-        const num = parseFloat(val);
-        if (isNaN(num)) {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `Must be a number. Got: ${val}` });
-            return z.NEVER;
-        }
-        if (num < -100 || num > 100) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Must be between -100 and 100. Got: ${val}`,
-            });
-            return z.NEVER;
-        }
-        return num;
-    }),
+    conviction: z.coerce.number().min(-100).max(100),
     text: z.string().min(1),
     token: z.string().min(1),
-    duration: z.string().transform((val, ctx) => {
-        const num = parseInt(val, 10);
-        if (isNaN(num) || num <= 0) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Must be a positive number. Got: ${val}`,
-            });
-            return z.NEVER;
-        }
-        return num;
-    }),
+    timeframe: z.enum(['1h', '4h', '24h']),
 });
 export function createMegathreadCreateCommentCommand() {
     return new Command('create-comment')
@@ -44,17 +21,14 @@ export function createMegathreadCreateCommentCommand() {
         .requiredOption('--conviction <number>', 'Conviction score (-100 to 100)')
         .requiredOption('--text <text>', 'Comment text')
         .requiredOption('--token <tokenId>', 'Token/project ID')
-        .requiredOption('--duration <ms>', 'Round duration in milliseconds')
+        .requiredOption('--timeframe <tf>', 'Timeframe (1h, 4h, 24h)')
         .action(async (options) => {
         const parseResult = CreateCommentOptionsSchema.safeParse(options);
         if (!parseResult.success) {
-            const errors = parseResult.error.issues
-                .map((e) => `${e.path.join('.')}: ${e.message}`)
-                .join(', ');
-            console.error(styled.red(`${symbols.cross} Validation error: ${errors}`));
+            printZodError(parseResult);
             process.exit(1);
         }
-        const { agent: agentName, round: roundId, conviction, text, token, duration, } = parseResult.data;
+        const { agent: agentName, round: roundId, conviction, text, token, timeframe, } = parseResult.data;
         const agentConfig = await findAgentByName(agentName);
         if (!agentConfig) {
             const agents = await scanAgents();
@@ -73,6 +47,7 @@ export function createMegathreadCreateCommentCommand() {
             process.exit(1);
         }
         const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
+        const duration = TIMEFRAME_DURATION_MS[timeframe];
         const payload = {
             text,
             conviction,

package/dist/commands/megathread/commands/create-comment.test.js

@@ -83,11 +83,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: 150');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction');
+            expect(consoleErrorOutput.join('\n')).toContain('100');
         });
         it('shows error when conviction is too low', async () => {
             const command = createMegathreadCreateCommentCommand();
@@ -102,11 +102,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: -150');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction');
+            expect(consoleErrorOutput.join('\n')).toContain('-100');
         });
         it('shows error when conviction is not a number', async () => {
             const command = createMegathreadCreateCommentCommand();
@@ -121,11 +121,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be a number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction');
+            expect(consoleErrorOutput.join('\n')).toContain('number');
         });
         it('accepts valid conviction at upper boundary', async () => {
             mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
@@ -142,8 +142,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -167,8 +167,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -192,8 +192,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -203,8 +203,8 @@ describe('createMegathreadCreateCommentCommand', () => {
             });
         });
     });
-    describe('duration validation', () => {
-        it('shows error when duration is negative', async () => {
+    describe('timeframe validation', () => {
+        it('shows error for invalid timeframe value', async () => {
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
                 '--agent',
@@ -217,15 +217,15 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '-1',
+                '--timeframe',
+                '2h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: -1');
         });
-        it('shows error when duration is zero', async () => {
+        it('accepts 1h timeframe', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
-            await expect(command.parseAsync([
+            await command.parseAsync([
                 '--agent',
                 'test-agent',
                 '--round',
@@ -236,15 +236,21 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '0',
-            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: 0');
+                '--timeframe',
+                '1h',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 50,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
         });
-        it('shows error when duration is not a number', async () => {
+        it('accepts 4h timeframe', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
-            await expect(command.parseAsync([
+            await command.parseAsync([
                 '--agent',
                 'test-agent',
                 '--round',
@@ -255,11 +261,40 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                'abc',
-            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+                '--timeframe',
+                '4h',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 50,
+                tokenId: 'bitcoin',
+                roundDuration: 14400000,
+            });
+        });
+        it('accepts 24h timeframe', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--timeframe',
+                '24h',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 50,
+                tokenId: 'bitcoin',
+                roundDuration: 86400000,
+            });
         });
     });
     describe('agent validation', () => {
@@ -276,8 +311,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Agent "non-existent" not found');
             expect(consoleErrorOutput.join('\n')).toContain('Available agents:');
@@ -301,8 +336,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found for agent "test-agent"');
         });
@@ -320,8 +355,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
         });
@@ -342,8 +377,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bullish on Bitcoin!',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Bullish on Bitcoin!',
@@ -373,8 +408,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bearish outlook',
                 '--token',
                 'ethereum',
-                '--duration',
-                '14400000',
+                '--timeframe',
+                '4h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('-30.0%');
@@ -395,8 +430,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 longText,
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             // Verify full text was sent to API
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
@@ -426,8 +461,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
             expect(consoleErrorOutput.join('\n')).toContain('Network error');
@@ -447,8 +482,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
             expect(consoleErrorOutput.join('\n')).toContain('String error');
@@ -470,8 +505,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('Comment posted successfully');

package/dist/commands/megathread/commands/list.js

@@ -1,47 +1,43 @@
 import { Command } from 'commander';
-import { HiveClient, TIMEFRAME_DURATION_MS, Timeframe } from '@zhive/sdk';
+import { HiveClient, durationMsToTimeframe } from '@zhive/sdk';
 import { styled, symbols, border } from '../../shared/theme.js';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { findAgentByName, loadAgentCredentials, scanAgents } from '../../../shared/config/agent.js';
+import z from 'zod';
+import { printZodError } from '../../shared/ validation.js';
 const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
-const DURATION_MS_TO_TIMEFRAME = {
-    [TIMEFRAME_DURATION_MS[Timeframe.H1]]: Timeframe.H1,
-    [TIMEFRAME_DURATION_MS[Timeframe.H4]]: Timeframe.H4,
-    [TIMEFRAME_DURATION_MS[Timeframe.H24]]: Timeframe.H24,
-};
-function durationMsToTimeframe(durationMs) {
-    const result = DURATION_MS_TO_TIMEFRAME[durationMs];
-    return result;
-}
-function parseTimeframes(raw) {
-    const parts = raw.split(',').map((t) => t.trim());
-    const invalid = parts.filter((t) => !VALID_TIMEFRAMES.includes(t));
-    if (invalid.length > 0) {
-        return null;
-    }
-    const parsed = parts;
-    return parsed;
-}
+const ListMegathreadOptionsSchema = z.object({
+    agent: z.string(),
+    timeframe: z
+        .string()
+        .optional()
+        .transform((val, ctx) => {
+        if (!val)
+            return undefined;
+        const parsed = val.split(',').map((t) => t.trim());
+        const invalidParts = parsed.filter((t) => !VALID_TIMEFRAMES.includes(t));
+        if (invalidParts.length > 0) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Invalid. valid values are [${VALID_TIMEFRAMES.join(', ')}]`,
+            });
+            return z.NEVER;
+        }
+        return parsed;
+    }),
+});
 export function createMegathreadListCommand() {
     const program = new Command('list')
         .description('List unpredicted megathread rounds of an agent')
         .requiredOption('--agent <name>', 'Agent name')
         .option('--timeframe <timeframes>', 'Filter by timeframes (comma-separated: 1h,4h,24h)')
         .action(async (options) => {
-        const { agent: agentName, timeframe: timeframeOption } = options;
-        let timeframes;
-        if (timeframeOption) {
-            const parsed = parseTimeframes(timeframeOption);
-            if (parsed === null) {
-                const invalidParts = timeframeOption
-                    .split(',')
-                    .map((t) => t.trim())
-                    .filter((t) => !VALID_TIMEFRAMES.includes(t));
-                console.error(styled.red(`${symbols.cross} Invalid timeframes: ${invalidParts.join(', ')}. Valid values: 1h, 4h, 24h`));
-                process.exit(1);
-            }
-            timeframes = parsed;
+        const parseResult = ListMegathreadOptionsSchema.safeParse(options);
+        if (!parseResult.success) {
+            printZodError(parseResult);
+            process.exit(1);
         }
+        const { agent: agentName, timeframe: timeframes } = parseResult.data;
         const agentConfig = await findAgentByName(agentName);
         if (!agentConfig) {
             const agents = await scanAgents();
@@ -70,11 +66,11 @@ export function createMegathreadListCommand() {
                 console.log('');
                 return;
             }
-            const headers = ['Round ID', 'Token', 'Timeframe'];
+            const headers = ['Round ID', 'Token', 'Timeframe', 'PriceAtStart'];
             const rows = rounds.map((r) => {
                 const tf = durationMsToTimeframe(r.durationMs);
                 const timeframeStr = tf ?? `${r.durationMs}ms`;
-                return [r.roundId, r.projectId, timeframeStr];
+                return [r.roundId, r.projectId, timeframeStr, r.priceAtStart];
             });
             const colWidths = headers.map((h, i) => {
                 const dataMax = Math.max(...rows.map((row) => String(row[i]).length));

package/dist/commands/megathread/commands/list.test.js

@@ -39,6 +39,7 @@ function createMockActiveRound(overrides = {}) {
         roundId: 'round-123',
         projectId: 'bitcoin',
         durationMs: 3600000,
+        priceAtStart: null,
         ...overrides,
     };
 }
@@ -78,13 +79,12 @@ describe('createMegathreadListCommand', () => {
         it('shows error for invalid timeframe value', async () => {
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent', '--timeframe', '2h'], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('Invalid timeframes: 2h');
-            expect(consoleErrorOutput.join('\n')).toContain('Valid values: 1h, 4h, 24h');
+            expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('shows error for multiple invalid timeframes', async () => {
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent', '--timeframe', '2h,5h'], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('Invalid timeframes: 2h, 5h');
+            expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('accepts valid timeframe values', async () => {
             mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });

package/dist/commands/shared/ validation.js

@@ -0,0 +1,5 @@
+import { styled, symbols } from './theme.js';
+export const printZodError = (result) => {
+    const errors = result.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+    console.error(styled.red(`${symbols.cross} Validation error: ${errors}`));
+};

package/dist/shared/config/constant.js

@@ -6,12 +6,16 @@ export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
 export function getHiveDir() {
     const homeDir = os.homedir();
     const zhiveDir = path.join(homeDir, '.zhive');
-    const legacyDir = path.join(homeDir, '.hive');
-    if (fs.existsSync(zhiveDir)) {
-        return zhiveDir;
-    }
-    if (fs.existsSync(legacyDir)) {
-        return legacyDir;
+    const pathToCheck = [
+        path.join(homeDir, '.zhive'),
+        path.join(homeDir, '.hive'), // legacy hive dir
+        path.join(homeDir, '.openclaw', '.hive'),
+        path.join(homeDir, '.openclaw', 'workspace', '.hive'),
+    ];
+    for (const p of pathToCheck) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
     }
     return zhiveDir;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "CLI for bootstrapping zHive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/xai": "^3.0.0",
     "@openrouter/ai-sdk-provider": "^0.4.0",
-    "@zhive/sdk": "^0.5.2",
+    "@zhive/sdk": "^0.5.4",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",