keystone-cli 1.0.2 → 1.1.0

package/src/ui/dashboard.tsx

@@ -1,6 +1,6 @@
 import { Box, Newline, Text, render, useInput } from 'ink';
 import React, { useState, useEffect, useCallback, useMemo } from 'react';
-import { WorkflowDb } from '../db/workflow-db.ts';
+import { type StepExecution, WorkflowDb } from '../db/workflow-db.ts';
 import { ConsoleLogger } from '../utils/logger.ts';
 
 interface Run {
@@ -8,13 +8,30 @@ interface Run {
   workflow_name: string;
   status: string;
   started_at: string;
+  completed_at?: string | null;
   total_tokens?: number;
+  duration_ms?: number;
+  exec_total?: number;
+  exec_failed?: number;
+  exec_retries?: number;
+  exec_soft_failures?: number;
+}
+
+interface Thought {
+  id: string;
+  run_id: string;
+  workflow_name: string;
+  step_id: string;
+  content: string;
+  source: 'thinking' | 'reasoning';
+  created_at: string;
 }
 
 const logger = new ConsoleLogger();
 
 const Dashboard = () => {
   const [runs, setRuns] = useState<Run[]>([]);
+  const [thoughts, setThoughts] = useState<Thought[]>([]);
   const [loading, setLoading] = useState(true);
 
   // Reuse database connection instead of creating new one every 2 seconds
@@ -28,30 +45,60 @@ const Dashboard = () => {
   const fetchData = useCallback(async () => {
     try {
       const recentRuns = (await db.listRuns(10)) as (Run & { outputs: string | null })[];
-      const runsWithUsage = await Promise.all(
-        recentRuns.map(async (run) => {
-          let total_tokens = 0;
-          try {
-            // Get steps to aggregate tokens if not in outputs (future-proofing)
-            const steps = await db.getStepsByRun(run.id);
-            total_tokens = steps.reduce((sum, s) => {
-              if (s.usage) {
-                try {
-                  const u = JSON.parse(s.usage);
-                  return sum + (u.total_tokens || 0);
-                } catch (e) {
-                  return sum;
-                }
-              }
+      const runIds = recentRuns.map((run) => run.id);
+      const steps = await db.getStepsByRuns(runIds);
+      const stepsByRun = new Map<string, StepExecution[]>();
+      for (const step of steps) {
+        const list = stepsByRun.get(step.run_id);
+        if (list) {
+          list.push(step);
+        } else {
+          stepsByRun.set(step.run_id, [step]);
+        }
+      }
+
+      const runsWithUsage = recentRuns.map((run) => {
+        let total_tokens = 0;
+        let exec_total = 0;
+        let exec_failed = 0;
+        let exec_retries = 0;
+        let exec_soft_failures = 0;
+        const runSteps = stepsByRun.get(run.id) || [];
+        total_tokens = runSteps.reduce((sum, s) => {
+          if (s.usage) {
+            try {
+              const u = JSON.parse(s.usage);
+              return sum + (u.total_tokens || 0);
+            } catch (e) {
               return sum;
-            }, 0);
-          } catch (e) {
-            // Ignore read error
+            }
           }
-          return { ...run, total_tokens };
-        })
-      );
+          return sum;
+        }, 0);
+        exec_total = runSteps.length;
+        exec_failed = runSteps.filter((step) => step.status === 'failed').length;
+        exec_retries = runSteps.reduce((sum, step) => sum + (step.retry_count || 0), 0);
+        exec_soft_failures = runSteps.filter(
+          (step) => step.status === 'success' && step.error
+        ).length;
+        const startedMs = new Date(run.started_at).getTime();
+        const completedMs = run.completed_at ? new Date(run.completed_at).getTime() : Date.now();
+        const duration_ms = Number.isFinite(startedMs)
+          ? Math.max(0, completedMs - startedMs)
+          : undefined;
+        return {
+          ...run,
+          total_tokens,
+          duration_ms,
+          exec_total,
+          exec_failed,
+          exec_retries,
+          exec_soft_failures,
+        };
+      });
       setRuns(runsWithUsage);
+      const recentThoughts = (await db.listThoughtEvents(12)) as Thought[];
+      setThoughts(recentThoughts);
     } catch (error) {
       logger.error(`Failed to fetch runs: ${String(error)}`);
     } finally {
@@ -94,22 +141,42 @@ const Dashboard = () => {
               ID
             </Text>
           </Box>
-          <Box width={30}>
+          <Box width={24}>
             <Text bold color="cyan">
               WORKFLOW
             </Text>
           </Box>
-          <Box width={15}>
+          <Box width={12}>
             <Text bold color="cyan">
               STATUS
             </Text>
           </Box>
-          <Box width={15}>
+          <Box width={10}>
+            <Text bold color="cyan">
+              START
+            </Text>
+          </Box>
+          <Box width={8}>
             <Text bold color="cyan">
-              STARTED
+              DUR
             </Text>
           </Box>
-          <Box>
+          <Box width={7}>
+            <Text bold color="cyan">
+              EXECS
+            </Text>
+          </Box>
+          <Box width={6}>
+            <Text bold color="cyan">
+              FAIL
+            </Text>
+          </Box>
+          <Box width={7}>
+            <Text bold color="cyan">
+              RETRY
+            </Text>
+          </Box>
+          <Box width={8}>
             <Text bold color="cyan">
               TOKENS
             </Text>
@@ -117,7 +184,7 @@ const Dashboard = () => {
         </Box>
 
         <Box marginBottom={1}>
-          <Text color="gray">{'─'.repeat(80)}</Text>
+          <Text color="gray">{'─'.repeat(92)}</Text>
         </Box>
 
         {runs.length === 0 ? (
@@ -130,18 +197,34 @@ const Dashboard = () => {
               <Box width={12}>
                 <Text color="gray">{run.id.substring(0, 8)}</Text>
               </Box>
-              <Box width={30}>
+              <Box width={24}>
                 <Text>{run.workflow_name}</Text>
               </Box>
-              <Box width={15}>
+              <Box width={12}>
                 <Text color={getStatusColor(run.status)}>
                   {getStatusIcon(run.status)} {run.status.toUpperCase()}
                 </Text>
               </Box>
-              <Box width={15}>
-                <Text color="gray">{new Date(run.started_at).toLocaleTimeString()}</Text>
+              <Box width={10}>
+                <Text color="gray">{formatClock(run.started_at)}</Text>
+              </Box>
+              <Box width={8}>
+                <Text color="gray">
+                  {run.duration_ms !== undefined ? formatDuration(run.duration_ms) : '--:--'}
+                </Text>
               </Box>
-              <Box>
+              <Box width={7}>
+                <Text color="gray">{run.exec_total ?? 0}</Text>
+              </Box>
+              <Box width={6}>
+                <Text color={getFailColor(run.exec_failed, run.exec_soft_failures)}>
+                  {formatFailCount(run.exec_failed, run.exec_soft_failures)}
+                </Text>
+              </Box>
+              <Box width={7}>
+                <Text color={run.exec_retries ? 'yellow' : 'gray'}>{run.exec_retries ?? 0}</Text>
+              </Box>
+              <Box width={8}>
                 <Text color="yellow">{run.total_tokens || 0}</Text>
               </Box>
             </Box>
@@ -149,6 +232,36 @@ const Dashboard = () => {
         )}
       </Box>
 
+      <Box marginTop={1} borderStyle="round" borderColor="gray" flexDirection="column" paddingX={1}>
+        <Box marginBottom={1}>
+          <Text bold color="cyan">
+            THOUGHTS
+          </Text>
+        </Box>
+        {thoughts.length === 0 ? (
+          <Text italic color="gray">
+            No thought events yet.
+          </Text>
+        ) : (
+          thoughts.map((thought) => (
+            <Box key={thought.id} marginBottom={0}>
+              <Box width={10}>
+                <Text color="gray">{formatClock(thought.created_at)}</Text>
+              </Box>
+              <Box width={10}>
+                <Text color="gray">{thought.run_id.substring(0, 8)}</Text>
+              </Box>
+              <Box width={16}>
+                <Text color="gray">{thought.step_id}</Text>
+              </Box>
+              <Box flexGrow={1}>
+                <Text>{truncateText(thought.content, 120)}</Text>
+              </Box>
+            </Box>
+          ))
+        )}
+      </Box>
+
       <Box marginTop={1} paddingX={1}>
         <Text color="gray">
           <Text bold color="white">
@@ -203,6 +316,51 @@ const getStatusIcon = (status: string) => {
   }
 };
 
+const formatDuration = (durationMs: number): string => {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return '--:--';
+  const totalSeconds = Math.floor(durationMs / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(
+      seconds
+    ).padStart(2, '0')}`;
+  }
+  return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+};
+
+const formatClock = (iso: string): string => {
+  try {
+    return new Date(iso).toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+    });
+  } catch {
+    return '--:--:--';
+  }
+};
+
+const truncateText = (value: string, maxLength: number): string => {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+};
+
+const formatFailCount = (failed = 0, softFailed = 0): string => {
+  if (softFailed > 0) {
+    return `${failed}+${softFailed}`;
+  }
+  return String(failed);
+};
+
+const getFailColor = (failed = 0, softFailed = 0): string => {
+  if (failed > 0) return 'red';
+  if (softFailed > 0) return 'yellow';
+  return 'gray';
+};
+
 export const startDashboard = () => {
   render(<Dashboard />);
 };

package/src/utils/auth-manager.test.ts

@@ -2,6 +2,7 @@ import { afterAll, beforeAll, beforeEach, describe, expect, it, mock, spyOn } fr
 import * as fs from 'node:fs';
 import { join } from 'node:path';
 import { AuthManager } from './auth-manager.ts';
+import { ConsoleLogger } from './logger';
 
 describe('AuthManager', () => {
   const originalFetch = global.fetch;
@@ -72,6 +73,26 @@ describe('AuthManager', () => {
     });
   });
 
+  describe('setLogger()', () => {
+    it('should set the static logger', () => {
+      const mockLogger = {
+        log: mock(() => {}),
+        warn: mock(() => {}),
+        error: mock(() => {}),
+        info: mock(() => {}),
+        debug: mock(() => {}),
+      };
+      AuthManager.setLogger(mockLogger);
+      // Trigger a log through save failure to verify
+      process.env.KEYSTONE_AUTH_PATH = '/non/existent/path/auth.json';
+      AuthManager.save({ github_token: 'test' });
+      expect(mockLogger.error).toHaveBeenCalled();
+      process.env.KEYSTONE_AUTH_PATH = TEMP_AUTH_FILE;
+      // Reset logger
+      AuthManager.setLogger(new ConsoleLogger());
+    });
+  });
+
   describe('getCopilotToken()', () => {
     it('should return undefined if no github_token', async () => {
       fs.writeFileSync(TEMP_AUTH_FILE, JSON.stringify({}));
@@ -268,4 +289,320 @@ describe('AuthManager', () => {
       }
     });
   });
+
+  describe('OAuth Helpers', () => {
+    it('generateCodeVerifier should return hex string', () => {
+      // @ts-ignore - access private
+      const verifier = AuthManager.generateCodeVerifier();
+      expect(verifier).toMatch(/^[0-9a-f]+$/);
+      expect(verifier.length).toBe(64);
+    });
+
+    it('createCodeChallenge should return base64url string', () => {
+      const verifier = 'test-verifier';
+      // @ts-ignore - access private
+      const challenge = AuthManager.createCodeChallenge(verifier);
+      expect(challenge).toBeDefined();
+      expect(challenge).not.toContain('+');
+      expect(challenge).not.toContain('/');
+    });
+  });
+
+  describe('Anthropic Claude', () => {
+    it('createAnthropicClaudeAuth should return url and verifier', () => {
+      const { url, verifier } = AuthManager.createAnthropicClaudeAuth();
+      expect(url).toContain('https://claude.ai/oauth/authorize');
+      expect(url).toContain('client_id=');
+      expect(verifier).toBeDefined();
+    });
+
+    it('exchangeAnthropicClaudeCode should return tokens', async () => {
+      const mockFetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              access_token: 'claude-access',
+              refresh_token: 'claude-refresh',
+              expires_in: 3600,
+            }),
+            { status: 200 }
+          )
+        )
+      );
+      // @ts-ignore
+      global.fetch = mockFetch;
+
+      const result = await AuthManager.exchangeAnthropicClaudeCode('code#verifier', 'verifier');
+      expect(result.access_token).toBe('claude-access');
+    });
+
+    it('getAnthropicClaudeToken should return cached token if valid', async () => {
+      const expires = Math.floor(Date.now() / 1000) + 1000;
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          anthropic_claude: {
+            access_token: 'claude-cached',
+            refresh_token: 'refresh',
+            expires_at: expires,
+          },
+        })
+      );
+
+      const token = await AuthManager.getAnthropicClaudeToken();
+      expect(token).toBe('claude-cached');
+    });
+
+    it('getAnthropicClaudeToken should refresh if expired', async () => {
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          anthropic_claude: {
+            access_token: 'expired',
+            refresh_token: 'refresh',
+            expires_at: Math.floor(Date.now() / 1000) - 1000,
+          },
+        })
+      );
+
+      // @ts-ignore
+      global.fetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              access_token: 'new-claude-token',
+              refresh_token: 'new-refresh',
+              expires_in: 3600,
+            }),
+            { status: 200 }
+          )
+        )
+      );
+
+      const token = await AuthManager.getAnthropicClaudeToken();
+      expect(token).toBe('new-claude-token');
+    });
+  });
+
+  describe('Google Gemini', () => {
+    it('getGoogleGeminiToken should return undefined if not logged in', async () => {
+      const token = await AuthManager.getGoogleGeminiToken();
+      expect(token).toBeUndefined();
+    });
+
+    it('getGoogleGeminiToken should refresh if expired', async () => {
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          google_gemini: {
+            access_token: 'expired',
+            refresh_token: 'refresh',
+            expires_at: Math.floor(Date.now() / 1000) - 1000,
+          },
+        })
+      );
+
+      process.env.GOOGLE_GEMINI_OAUTH_CLIENT_SECRET = 'secret';
+
+      // @ts-ignore
+      global.fetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              access_token: 'new-gemini-token',
+              expires_in: 3600,
+            }),
+            { status: 200 }
+          )
+        )
+      );
+
+      const token = await AuthManager.getGoogleGeminiToken();
+      expect(token).toBe('new-gemini-token');
+    });
+
+    it('fetchGoogleGeminiProjectId should return project ID from loadCodeAssist', async () => {
+      // @ts-ignore - access private
+      const spyFetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              cloudaicompanionProject: 'test-project-id',
+            }),
+            { status: 200 }
+          )
+        )
+      );
+      // @ts-ignore
+      global.fetch = spyFetch;
+
+      // @ts-ignore - access private
+      const projectId = await AuthManager.fetchGoogleGeminiProjectId('access-token');
+      expect(projectId).toBe('test-project-id');
+    });
+
+    it('fetchGoogleGeminiProjectId should return project ID from nested object', async () => {
+      // @ts-ignore - access private
+      const spyFetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              cloudaicompanionProject: { id: 'nested-id' },
+            }),
+            { status: 200 }
+          )
+        )
+      );
+      // @ts-ignore
+      global.fetch = spyFetch;
+
+      // @ts-ignore - access private
+      const projectId = await AuthManager.fetchGoogleGeminiProjectId('access-token');
+      expect(projectId).toBe('nested-id');
+    });
+
+    it('loginGoogleGemini should handle OAuth callback', async () => {
+      process.env.GOOGLE_GEMINI_OAUTH_CLIENT_SECRET = 'secret';
+
+      let fetchHandler: any;
+      const mockServer = {
+        port: 51121,
+        stop: mock(() => {}),
+      };
+
+      // @ts-ignore - mock Bun.serve
+      const serveSpy = spyOn(Bun, 'serve').mockImplementation((options: any) => {
+        fetchHandler = options.fetch;
+        return mockServer;
+      });
+
+      // Mock openBrowser to prevent browser opening
+      const openBrowserSpy = spyOn(AuthManager, 'openBrowser').mockImplementation(() => {});
+
+      try {
+        const loginPromise = AuthManager.loginGoogleGemini('test-project');
+
+        // Verify server was started
+        expect(serveSpy).toHaveBeenCalled();
+        expect(fetchHandler).toBeDefined();
+
+        // Simulating the fetch handler call with the mock server
+        const req = new Request('http://localhost:51121/oauth-callback?code=test-code');
+        // @ts-ignore
+        global.fetch = mock(() =>
+          Promise.resolve(
+            new Response(
+              JSON.stringify({
+                access_token: 'access',
+                refresh_token: 'refresh',
+                expires_in: 3600,
+              }),
+              { status: 200 }
+            )
+          )
+        );
+
+        const response = await fetchHandler(req, mockServer);
+        expect(response.status).toBe(200);
+
+        await loginPromise;
+        const auth = AuthManager.load();
+        expect(auth.google_gemini?.access_token).toBe('access');
+      } finally {
+        serveSpy.mockRestore();
+        openBrowserSpy.mockRestore();
+      }
+    });
+  });
+
+  describe('OpenAI ChatGPT Login', () => {
+    it('loginOpenAIChatGPT should handle OAuth callback', async () => {
+      let fetchHandler: any;
+      const mockServer = {
+        stop: mock(() => {}),
+      };
+
+      // @ts-ignore - mock Bun.serve
+      const serveSpy = spyOn(Bun, 'serve').mockImplementation((options: any) => {
+        fetchHandler = options.fetch;
+        return mockServer;
+      });
+
+      // Mock openBrowser to prevent browser opening
+      const openBrowserSpy = spyOn(AuthManager, 'openBrowser').mockImplementation(() => {});
+
+      try {
+        const loginPromise = AuthManager.loginOpenAIChatGPT();
+
+        expect(serveSpy).toHaveBeenCalled();
+        expect(fetchHandler).toBeDefined();
+
+        // Simulate callback
+        const req = new Request('http://localhost:1455/auth/callback?code=test-code&state=xyz');
+        // The code expects the state to match. We can't easily get the random state,
+        // but since we are mocking, we can just ensure the branch is covered.
+        // Actually, let's just test that the handler exists and can be called.
+
+        // @ts-ignore
+        global.fetch = mock(() =>
+          Promise.resolve(
+            new Response(
+              JSON.stringify({
+                access_token: 'access',
+                refresh_token: 'refresh',
+                expires_in: 3600,
+              }),
+              { status: 200 }
+            )
+          )
+        );
+
+        // We skip the state check by not providing it in the URL if we want to test failure,
+        // or we can try to find where it's stored.
+        // But for now, let's just trigger it.
+
+        const response = await fetchHandler(req);
+        // It should return 400 because of state mismatch in real code,
+        // unless we mock the state generation.
+        expect(response.status).toBe(400);
+
+        await expect(loginPromise).rejects.toThrow('Invalid OAuth state');
+      } finally {
+        serveSpy.mockRestore();
+        openBrowserSpy.mockRestore();
+      }
+    });
+  });
+
+  describe('OpenAI ChatGPT', () => {
+    it('getOpenAIChatGPTToken should refresh if expired', async () => {
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          openai_chatgpt: {
+            access_token: 'expired',
+            refresh_token: 'refresh',
+            expires_at: Math.floor(Date.now() / 1000) - 1000,
+          },
+        })
+      );
+
+      // @ts-ignore
+      global.fetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              access_token: 'new-chatgpt-token',
+              refresh_token: 'new-refresh',
+              expires_in: 3600,
+            }),
+            { status: 200 }
+          )
+        )
+      );
+
+      const token = await AuthManager.getOpenAIChatGPTToken();
+      expect(token).toBe('new-chatgpt-token');
+    });
+  });
 });