@tyvm/knowhow 0.0.35 → 0.0.37

package/src/plugins/downloader/downloader.ts

@@ -8,11 +8,12 @@ import { execAsync, fileExists, readFile, mkdir } from "../../utils";
 import OpenAI from "openai";
 import { Clients } from "../../clients";
 import { Models } from "../../types";
+import { openai } from "../../ai";
 
 const logger = Logger();
 
 export class DownloaderService {
-  constructor(private openAi: OpenAI, private clients: typeof Clients) {}
+  constructor(private clients: typeof Clients) {}
 
   async askGptVision(
     imageUrl: string,
@@ -65,36 +66,6 @@ export class DownloaderService {
     return info;
   }
 
-  private async acquireLock(
-    lockPath: string,
-    timeoutMs = 30000
-  ): Promise<() => void> {
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < timeoutMs) {
-      try {
-        await fs.promises.writeFile(lockPath, process.pid.toString(), {
-          flag: "wx",
-        });
-        console.log(`Lock acquired: ${lockPath}`);
-        return async () => {
-          try {
-            await fs.promises.unlink(lockPath);
-            console.log(`Lock released: ${lockPath}`);
-          } catch (error) {
-            console.warn(`Failed to release lock ${lockPath}:`, error);
-          }
-        };
-      } catch (error) {
-        if (error.code !== "EEXIST") {
-          throw error;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-    }
-    throw new Error(`Failed to acquire lock ${lockPath} within ${timeoutMs}ms`);
-  }
-
   public async chunk(
     filePath: string,
     outputDir: string,
@@ -107,54 +78,43 @@ export class DownloaderService {
     console.log({ fileName, fileExt });
     console.log("Chunking file", filePath);
 
-    // Create lock to prevent concurrent chunking of the same file
-    const lockPath = path.join(outputDir, `${fileName}.chunking.lock`);
-    const releaseLock = await this.acquireLock(lockPath);
-
-    try {
-      // create a temp directory
-      const outputDirPath = path.join(outputDir, `${fileName}/chunks`);
-      await fs.promises.mkdir(outputDirPath, { recursive: true });
-      const existingFolderFiles = await fs.promises.readdir(outputDirPath);
-      const existingChunkNames = existingFolderFiles.filter(
-        (f) => f.includes("chunk") && f.endsWith(".mp3")
-      );
+    // create a temp directory
+    const outputDirPath = path.join(outputDir, `${fileName}/chunks`);
+    await fs.promises.mkdir(outputDirPath, { recursive: true });
+    const doneFilePath = path.join(outputDirPath, ".chunking_done");
 
-      if (existingChunkNames.length > 0) {
-        if (reuseExistingChunks) {
-          console.log("Chunks already exist, skipping");
-          await releaseLock();
-          const names = existingChunkNames.map((chunkName) =>
-            path.join(outputDirPath, chunkName)
-          );
-          return names;
-        } else {
-          for (const file of existingFolderFiles) {
-            fs.rmSync(path.join(outputDirPath, file), { recursive: true });
-          }
+    const doneFileExists = await fileExists(doneFilePath);
+    const existingFolderFiles = await fs.promises.readdir(outputDirPath);
+    const existingChunkNames = existingFolderFiles.filter(
+      (f) => f.includes("chunk") && f.endsWith(".mp3")
+    );
+
+    if (existingChunkNames.length > 0 && doneFileExists) {
+      if (reuseExistingChunks) {
+        console.log("Chunks already exist, skipping");
+        const names = existingChunkNames.map((chunkName) =>
+          path.join(outputDirPath, chunkName)
+        );
+        return names;
+      } else {
+        for (const file of existingFolderFiles) {
+          fs.rmSync(path.join(outputDirPath, file), { recursive: true });
         }
       }
+    }
 
-      const command = `ffmpeg -i "${filePath}" -f segment -segment_time ${CHUNK_LENGTH_SECONDS} -map 0:a:0 -acodec mp3 -vn "${outputDirPath}/chunk%04d.mp3"`;
-      await execAsync(command);
+    const command = `ffmpeg -i "${filePath}" -f segment -segment_time ${CHUNK_LENGTH_SECONDS} -map 0:a:0 -acodec mp3 -vn "${outputDirPath}/chunk%04d.mp3"`;
+    await execAsync(command);
+    await fs.promises.writeFile(doneFilePath, "done");
 
-      const folderFiles = await fs.promises.readdir(outputDirPath);
-      const chunkNames = folderFiles.filter(
-        (f) => f.includes("chunk") && f.endsWith(".mp3")
-      );
-      console.log("Chunked into", chunkNames.length, "chunks");
-      return chunkNames.map((chunkName) => path.join(outputDirPath, chunkName));
-    } catch (error) {
-      console.error("Error during chunking:", error);
-      throw error;
-    } finally {
-      await releaseLock();
-    }
+    const folderFiles = await fs.promises.readdir(outputDirPath);
+    const chunkNames = folderFiles.filter(
+      (f) => f.includes("chunk") && f.endsWith(".mp3")
+    );
+    console.log("Chunked into", chunkNames.length, "chunks");
+    return chunkNames.map((chunkName) => path.join(outputDirPath, chunkName));
   }
 
-  // Add transcription locking to prevent race conditions
-  private transcriptionLocks = new Map<string, Promise<TranscriptChunk[]>>();
-
   public async *streamTranscription(
     files: string[],
     outputPath: string,
@@ -171,56 +131,8 @@ export class DownloaderService {
       return;
     }
 
-    // Prevent concurrent transcription of the same output file
-    const lockKey = outputPath;
-    if (this.transcriptionLocks.has(lockKey)) {
-      console.log("Waiting for concurrent transcription to complete...");
-      await this.transcriptionLocks.get(lockKey);
-      // After waiting, check again if file exists
-      const existsNow = await fileExists(outputPath);
-      if (existsNow && reusePreviousTranscript) {
-        console.log(
-          "Transcription completed by concurrent process, using cached data"
-        );
-        const contents = await readFile(outputPath);
-        const data = JSON.parse(contents.toString()) as TranscriptChunk[];
-        for (const item of data) {
-          yield item;
-        }
-        return;
-      }
-    }
-
-    // Create a promise for this transcription operation
-    const transcriptionPromise = (async () => {
-      const results: TranscriptChunk[] = [];
-      for await (const chunk of this.performTranscription(
-        files,
-        outputPath,
-        reusePreviousTranscript
-      )) {
-        results.push(chunk);
-      }
-      return results;
-    })();
-    this.transcriptionLocks.set(lockKey, transcriptionPromise);
-
-    try {
-      const results = await transcriptionPromise;
-      for (const chunk of results) {
-        yield chunk;
-      }
-    } finally {
-      this.transcriptionLocks.delete(lockKey);
-    }
-  }
-
-  private async *performTranscription(
-    files: string[],
-    outputPath: string,
-    reusePreviousTranscript: boolean
-  ): AsyncGenerator<TranscriptChunk> {
     const allTranscripts = [];
+    const openAi = openai();
     for (const file of files) {
       const chunkName = path.parse(file).name;
       const chunkTranscriptPath = path.join(
@@ -247,7 +159,7 @@ export class DownloaderService {
       }
 
       console.log("Transcribing", file);
-      const transcript = await this.openAi.audio.transcriptions
+      const transcript = await openAi.audio.transcriptions
         .create({
           file: fs.createReadStream(file),
           model: "whisper-1",

package/src/services/KnowhowClient.ts

@@ -128,6 +128,9 @@ export class KnowhowSimpleClient {
   getModels() {
     this.checkJwt();
     return axios.get(`${this.baseUrl}/api/proxy/v1/models`, {
+      params: {
+        type: 'all'
+      },
       headers: this.headers,
     });
   }

package/src/services/index.ts

@@ -1,4 +1,3 @@
-import { openai } from "../ai";
 import { DownloaderService } from "../plugins/downloader/downloader";
 import { Clients } from "../clients";
 import { Plugins } from "../plugins/plugins";
@@ -41,7 +40,7 @@ export const services = (): typeof Singletons => {
     const Tools = new ToolsService();
     const Events = new EventService();
     const Agents = new AgentService(Tools, Events);
-    const Downloader = new DownloaderService(openai, Clients);
+    const Downloader = new DownloaderService(Clients);
     Singletons = {
       Tools,
       Events,

package/tests/manual/browser-login/README.md

@@ -0,0 +1,189 @@
+# Browser Login Manual Tests
+
+This directory contains comprehensive manual tests for the browser-based login functionality in the Knowhow CLI.
+
+## Test Overview
+
+The browser login implementation includes the following key features:
+- Browser-based authentication as the default login method
+- Cross-platform browser opening (macOS, Windows, Linux)
+- Polling mechanism with exponential backoff
+- JWT token retrieval and secure storage
+- Graceful error handling and user cancellation
+- Backwards compatibility with `--jwt` flag
+
+## Test Files
+
+### 1. `test_browser_login_basic.ts`
+**Purpose**: Tests the core browser login flow end-to-end
+
+**What it tests**:
+- Session creation with the API
+- Browser opening for user authentication
+- Authentication polling and completion
+- JWT retrieval and secure storage
+- File permissions (0o600)
+- JWT format validation
+
+**Prerequisites**:
+- Valid `KNOWHOW_API_URL` environment variable
+- Network connection to Knowhow API
+- Default browser available
+
+**Usage**:
+```bash
+npx tsx ./tests/manual/browser-login/test_browser_login_basic.ts
+```
+
+**Manual steps required**:
+- Complete authentication in the opened browser window
+- Verify browser opened to correct URL
+
+### 2. `test_cli_integration.ts`
+**Purpose**: Tests CLI command integration and backwards compatibility
+
+**What it tests**:
+- `knowhow login` uses browser login by default
+- `knowhow login --jwt` prompts for manual JWT input
+- Command help shows correct options
+- JWT file creation through CLI
+
+**Prerequisites**:
+- Built CLI application (`npm run build`)
+- Valid `KNOWHOW_API_URL` environment variable
+
+**Usage**:
+```bash
+npx tsx ./tests/manual/browser-login/test_cli_integration.ts
+```
+
+**Manual steps required**:
+- Complete browser authentication when prompted
+- Verify help output is correct
+
+### 3. `test_cross_platform_browser.ts`
+**Purpose**: Tests browser opening across different operating systems
+
+**What it tests**:
+- Platform detection (macOS, Windows, Linux)
+- Correct browser command selection (`open`, `start`, `xdg-open`)
+- Browser command availability
+- URL handling with special characters
+- Graceful fallback when browser opening fails
+
+**Prerequisites**:
+- Default browser installed
+- Platform-specific browser commands available
+
+**Usage**:
+```bash
+npx tsx ./tests/manual/browser-login/test_cross_platform_browser.ts
+```
+
+**Manual steps required**:
+- Verify browser opens to test URLs
+- Confirm platform-specific behavior
+
+### 4. `test_error_scenarios.ts`
+**Purpose**: Tests error handling and edge cases
+
+**What it tests**:
+- Invalid API URL handling
+- Missing API URL configuration
+- JWT validation with various inputs
+- File permission handling
+- Error code propagation
+- Graceful cancellation mechanisms
+
+**Prerequisites**:
+- Ability to modify environment variables temporarily
+
+**Usage**:
+```bash
+npx tsx ./tests/manual/browser-login/test_error_scenarios.ts
+```
+
+**Manual steps required**:
+- None (fully automated error scenario testing)
+
+## Running All Tests
+
+To run all tests in sequence:
+
+```bash
+# Run individual tests
+npx tsx ./tests/manual/browser-login/test_error_scenarios.ts
+npx tsx ./tests/manual/browser-login/test_cross_platform_browser.ts
+npx tsx ./tests/manual/browser-login/test_cli_integration.ts
+npx tsx ./tests/manual/browser-login/test_browser_login_basic.ts
+```
+
+## Test Results Interpretation
+
+### ✅ PASSED
+Test completed successfully with expected behavior.
+
+### ⚠️ WARNING  
+Test completed but with minor issues or platform-specific concerns that don't prevent functionality.
+
+### ❌ FAILED
+Test failed due to errors or unexpected behavior that needs to be addressed.
+
+### Manual Verification Required
+Some tests require manual verification (e.g., confirming browser opened correctly) as they test user interaction flows.
+
+## Common Issues and Troubleshooting
+
+### Browser Not Opening
+- **Symptoms**: Browser opening fails or command not found
+- **Solutions**: 
+  - Ensure default browser is installed
+  - Check platform-specific command availability (`open`, `start`, `xdg-open`)
+  - Verify display environment for Linux systems
+
+### Network Errors
+- **Symptoms**: API connection failures or timeouts
+- **Solutions**:
+  - Verify `KNOWHOW_API_URL` is set correctly
+  - Check network connectivity
+  - Confirm API endpoints are accessible
+
+### Permission Errors
+- **Symptoms**: Cannot create or write JWT files
+- **Solutions**:
+  - Check write permissions in project directory
+  - Verify `.knowhow` directory can be created
+  - Check for filesystem restrictions
+
+### Authentication Timeout
+- **Symptoms**: Polling times out before user completes authentication
+- **Solutions**:
+  - Complete authentication more quickly
+  - Check if browser session is blocked by ad blockers
+  - Verify correct authentication URL
+
+## Integration with CI/CD
+
+These manual tests are designed for human verification and are not suitable for automated CI/CD pipelines. For automated testing, consider:
+
+1. Mocking the browser opening functionality
+2. Creating integration tests with test authentication endpoints
+3. Unit testing individual components separately
+
+## Security Considerations
+
+When running these tests:
+- JWT tokens are stored temporarily and cleaned up
+- File permissions are tested to ensure secure storage (0o600)
+- No sensitive data should be logged or persisted beyond test execution
+- Tests clean up after themselves to avoid leaving test artifacts
+
+## Contributing
+
+When adding new tests:
+1. Follow the existing test file naming pattern
+2. Include comprehensive error handling
+3. Provide clear manual steps in comments
+4. Clean up any created files or state
+5. Add appropriate timeout handling
+6. Update this README with new test descriptions

package/tests/manual/browser-login/test_browser_login_basic.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Manual Test: Basic Browser Login Flow
+ * 
+ * This test validates the complete browser-based authentication flow:
+ * 1. Creates a login session with the API
+ * 2. Opens browser for user authentication
+ * 3. Polls for authentication completion
+ * 4. Retrieves and stores JWT token
+ * 
+ * Prerequisites:
+ * - Valid KNOWHOW_API_URL environment variable
+ * - Network connection to Knowhow API
+ * - Browser available on the system
+ * 
+ * Usage: npx tsx ./tests/manual/browser-login/test_browser_login_basic.ts
+ */
+
+import { BrowserLoginService } from '../../../src/auth/browserLogin';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function testBasicBrowserLogin(): Promise<void> {
+  console.log('\n=== Basic Browser Login Test ===\n');
+  
+  let success = false;
+  const configDir = path.join(process.cwd(), '.knowhow');
+  const jwtFile = path.join(configDir, '.jwt');
+  
+  // Clean up any existing JWT file
+  if (fs.existsSync(jwtFile)) {
+    fs.unlinkSync(jwtFile);
+    console.log('🧹 Cleaned up existing JWT file');
+  }
+  
+  try {
+    console.log('1. Initializing BrowserLoginService...');
+    const browserLogin = new BrowserLoginService();
+    
+    console.log('2. Starting browser login flow...');
+    console.log('   Note: This will open your browser and require manual authentication');
+    console.log('   Please complete the authentication process in your browser');
+    
+    await browserLogin.login();
+    
+    console.log('3. Verifying JWT file was created...');
+    if (fs.existsSync(jwtFile)) {
+      const jwtContent = fs.readFileSync(jwtFile, 'utf8');
+      
+      // Check file permissions
+      const stats = fs.statSync(jwtFile);
+      const permissions = stats.mode & parseInt('777', 8);
+      
+      console.log(`   ✅ JWT file created: ${jwtFile}`);
+      console.log(`   ✅ JWT length: ${jwtContent.length} characters`);
+      console.log(`   ✅ File permissions: ${permissions.toString(8)} (should be 600)`);
+      
+      // Basic JWT validation
+      const parts = jwtContent.split('.');
+      if (parts.length === 3) {
+        console.log('   ✅ JWT has correct structure (3 parts)');
+        success = true;
+      } else {
+        console.log('   ❌ JWT has incorrect structure');
+      }
+      
+      if (permissions === parseInt('600', 8)) {
+        console.log('   ✅ JWT file has correct permissions (600)');
+      } else {
+        console.log(`   ⚠️  JWT file permissions may be incorrect: ${permissions.toString(8)}`);
+      }
+      
+    } else {
+      console.log('   ❌ JWT file was not created');
+    }
+    
+  } catch (error) {
+    console.error('❌ Test failed with error:', error.message);
+    
+    if (error.code === 'USER_CANCELLED') {
+      console.log('   ℹ️  Authentication was cancelled by user (this is expected for Ctrl+C)');
+    } else if (error.code === 'TIMEOUT') {
+      console.log('   ⚠️  Authentication timed out (user may not have completed authentication)');
+    } else if (error.code === 'NETWORK_ERROR') {
+      console.log('   ❌ Network error - check API connectivity');
+    }
+  }
+  
+  console.log('\n=== Test Results ===');
+  if (success) {
+    console.log('✅ Browser login test PASSED');
+    console.log('   - Session created successfully');
+    console.log('   - Browser opened for authentication');
+    console.log('   - JWT retrieved and stored securely');
+    process.exit(0);
+  } else {
+    console.log('❌ Browser login test FAILED');
+    console.log('   See error details above');
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n\n🛑 Test interrupted by user (Ctrl+C)');
+  console.log('   This tests the graceful cancellation feature');
+  process.exit(0);
+});
+
+// Run the test
+testBasicBrowserLogin().catch((error) => {
+  console.error('Unhandled error:', error);
+  process.exit(1);
+});