@projectservan8n/cnapse 0.2.1 → 0.5.0

package/src/hooks/useTelegram.ts

@@ -0,0 +1,91 @@
+/**
+ * Telegram Hook - Remote PC control via Telegram bot
+ */
+
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { getTelegramBot, TelegramMessage } from '../services/telegram.js';
+
+export interface UseTelegramResult {
+  isEnabled: boolean;
+  isStarting: boolean;
+  error: string | null;
+  lastMessage: TelegramMessage | null;
+  toggle: () => Promise<void>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+}
+
+export function useTelegram(onMessage?: (msg: TelegramMessage) => void): UseTelegramResult {
+  const [isEnabled, setIsEnabled] = useState(false);
+  const [isStarting, setIsStarting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [lastMessage, setLastMessage] = useState<TelegramMessage | null>(null);
+  const onMessageRef = useRef(onMessage);
+
+  // Keep callback ref updated
+  useEffect(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+
+  const start = useCallback(async () => {
+    if (isEnabled) return;
+
+    setIsStarting(true);
+    setError(null);
+
+    try {
+      const bot = getTelegramBot();
+
+      // Setup event handlers
+      bot.on('message', (msg: TelegramMessage) => {
+        setLastMessage(msg);
+        onMessageRef.current?.(msg);
+      });
+
+      bot.on('error', (err: Error) => {
+        setError(err.message);
+      });
+
+      await bot.start();
+      setIsEnabled(true);
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to start Telegram bot';
+      setError(errorMsg);
+      throw err;
+    } finally {
+      setIsStarting(false);
+    }
+  }, [isEnabled]);
+
+  const stop = useCallback(async () => {
+    if (!isEnabled) return;
+
+    try {
+      const bot = getTelegramBot();
+      await bot.stop();
+      setIsEnabled(false);
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to stop Telegram bot';
+      setError(errorMsg);
+      throw err;
+    }
+  }, [isEnabled]);
+
+  const toggle = useCallback(async () => {
+    if (isEnabled) {
+      await stop();
+    } else {
+      await start();
+    }
+  }, [isEnabled, start, stop]);
+
+  return {
+    isEnabled,
+    isStarting,
+    error,
+    lastMessage,
+    toggle,
+    start,
+    stop,
+  };
+}

package/src/hooks/useVision.ts

@@ -0,0 +1,47 @@
+/**
+ * Vision Hook - Screenshot capture and AI description
+ */
+
+import { useState, useCallback } from 'react';
+import { describeScreen } from '../lib/vision.js';
+
+export interface UseVisionResult {
+  isAnalyzing: boolean;
+  lastDescription: string | null;
+  lastScreenshot: string | null;
+  error: string | null;
+  analyze: () => Promise<string>;
+}
+
+export function useVision(): UseVisionResult {
+  const [isAnalyzing, setIsAnalyzing] = useState(false);
+  const [lastDescription, setLastDescription] = useState<string | null>(null);
+  const [lastScreenshot, setLastScreenshot] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const analyze = useCallback(async (): Promise<string> => {
+    setIsAnalyzing(true);
+    setError(null);
+
+    try {
+      const result = await describeScreen();
+      setLastDescription(result.description);
+      setLastScreenshot(result.screenshot);
+      return result.description;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Vision analysis failed';
+      setError(errorMsg);
+      throw err;
+    } finally {
+      setIsAnalyzing(false);
+    }
+  }, []);
+
+  return {
+    isAnalyzing,
+    lastDescription,
+    lastScreenshot,
+    error,
+    analyze,
+  };
+}

package/src/index.tsx

@@ -112,56 +112,9 @@ Manual Setup:
     }
 
     case 'init': {
-      // Interactive setup
-      const readline = await import('readline');
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      const question = (q: string): Promise<string> =>
-        new Promise((resolve) => rl.question(q, resolve));
-
-      console.log('\n🚀 C-napse Setup\n');
-
-      console.log('Select a provider:');
-      console.log('  1. ollama     - Local AI (free, requires Ollama installed)');
-      console.log('  2. openrouter - OpenRouter API (pay per use, many models)');
-      console.log('  3. anthropic  - Anthropic Claude (pay per use)');
-      console.log('  4. openai     - OpenAI GPT (pay per use)');
-      console.log('');
-
-      const providerChoice = await question('Enter choice (1-4) [1]: ');
-      const providers = ['ollama', 'openrouter', 'anthropic', 'openai'] as const;
-      const providerIndex = parseInt(providerChoice || '1') - 1;
-      const provider = providers[providerIndex] || 'ollama';
-
-      setProvider(provider);
-      console.log(`✓ Provider set to: ${provider}`);
-
-      if (provider !== 'ollama') {
-        const apiKey = await question(`\nEnter your ${provider} API key: `);
-        if (apiKey) {
-          setApiKey(provider as any, apiKey);
-          console.log(`✓ API key saved`);
-        }
-      }
-
-      // Set default model based on provider
-      const defaultModels: Record<string, string> = {
-        ollama: 'qwen2.5:0.5b',
-        openrouter: 'qwen/qwen-2.5-coder-32b-instruct',
-        anthropic: 'claude-3-5-sonnet-20241022',
-        openai: 'gpt-4o',
-      };
-
-      const model = await question(`\nModel [${defaultModels[provider]}]: `);
-      setModel(model || defaultModels[provider]!);
-      console.log(`✓ Model set to: ${model || defaultModels[provider]}`);
-
-      rl.close();
-
-      console.log('\n✅ Setup complete! Run `cnapse` to start chatting.\n');
+      // Interactive setup with Ink UI
+      const { Setup } = await import('./components/Setup.js');
+      render(<Setup />);
       process.exit(0);
     }
 

package/src/lib/api.ts

@@ -18,11 +18,11 @@ When responding:
 - Use markdown formatting for code blocks
 - If asked to do something, explain what you'll do first`;
 
-export async function chat(messages: Message[]): Promise<ChatResponse> {
+export async function chat(messages: Message[], systemPrompt?: string): Promise<ChatResponse> {
   const config = getConfig();
 
   const allMessages: Message[] = [
-    { role: 'system', content: SYSTEM_PROMPT },
+    { role: 'system', content: systemPrompt || SYSTEM_PROMPT },
     ...messages,
   ];
 

package/src/lib/config.ts

@@ -7,12 +7,17 @@ interface ConfigSchema {
     openrouter?: string;
     anthropic?: string;
     openai?: string;
+    telegram?: string;
   };
   ollamaHost: string;
   openrouter: {
     siteUrl: string;
     appName: string;
   };
+  telegram: {
+    chatId?: number;
+    enabled: boolean;
+  };
 }
 
 const config = new Conf<ConfigSchema>({
@@ -26,6 +31,9 @@ const config = new Conf<ConfigSchema>({
       siteUrl: 'https://github.com/projectservan8n/C-napse',
       appName: 'C-napse',
     },
+    telegram: {
+      enabled: false,
+    },
   },
 });
 
@@ -36,6 +44,7 @@ export function getConfig() {
     apiKeys: config.get('apiKeys'),
     ollamaHost: config.get('ollamaHost'),
     openrouter: config.get('openrouter'),
+    telegram: config.get('telegram'),
   };
 }
 
@@ -57,4 +66,16 @@ export function getApiKey(provider: keyof ConfigSchema['apiKeys']): string | und
   return config.get('apiKeys')[provider];
 }
 
+export function setTelegramChatId(chatId: number) {
+  const telegram = config.get('telegram');
+  telegram.chatId = chatId;
+  config.set('telegram', telegram);
+}
+
+export function setTelegramEnabled(enabled: boolean) {
+  const telegram = config.get('telegram');
+  telegram.enabled = enabled;
+  config.set('telegram', telegram);
+}
+
 export { config };

package/src/lib/screen.ts

@@ -0,0 +1,118 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { readFile, unlink } from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+let lastScreenHash: string | null = null;
+let isCapturing = false;
+
+/**
+ * Capture screenshot and return base64 encoded image
+ * Uses platform-specific tools
+ */
+export async function captureScreen(): Promise<string | null> {
+  if (isCapturing) return null;
+  isCapturing = true;
+
+  const tempFile = join(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+
+  try {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      // Windows: Use PowerShell to capture screen
+      await execAsync(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+        $bitmap = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
+        $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+        $graphics.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size)
+        $bitmap.Save("${tempFile.replace(/\\/g, '\\\\')}")
+        $graphics.Dispose()
+        $bitmap.Dispose()
+      `, { shell: 'powershell.exe' });
+    } else if (platform === 'darwin') {
+      // macOS: Use screencapture
+      await execAsync(`screencapture -x "${tempFile}"`);
+    } else {
+      // Linux: Try various tools
+      try {
+        await execAsync(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
+      } catch {
+        return null;
+      }
+    }
+
+    // Read the file and convert to base64
+    const imageBuffer = await readFile(tempFile);
+    const base64 = imageBuffer.toString('base64');
+
+    // Clean up
+    await unlink(tempFile).catch(() => {});
+
+    return base64;
+  } catch (error) {
+    return null;
+  } finally {
+    isCapturing = false;
+  }
+}
+
+/**
+ * Simple hash function for change detection
+ */
+function simpleHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i += 100) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+
+/**
+ * Check if screen has changed since last capture
+ */
+export async function checkScreenChange(): Promise<{ changed: boolean; image: string | null }> {
+  const image = await captureScreen();
+
+  if (!image) {
+    return { changed: false, image: null };
+  }
+
+  const currentHash = simpleHash(image);
+  const changed = lastScreenHash !== null && lastScreenHash !== currentHash;
+  lastScreenHash = currentHash;
+
+  return { changed, image };
+}
+
+/**
+ * Get screen description for context (simplified - just dimensions)
+ */
+export async function getScreenDescription(): Promise<string | null> {
+  try {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      const { stdout } = await execAsync(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+        Write-Output "$($screen.Width)x$($screen.Height)"
+      `, { shell: 'powershell.exe' });
+      return `Screen ${stdout.trim()} captured`;
+    } else if (platform === 'darwin') {
+      const { stdout } = await execAsync(`system_profiler SPDisplaysDataType | grep Resolution | head -1`);
+      return `Screen ${stdout.trim()}`;
+    } else {
+      const { stdout } = await execAsync(`xdpyinfo | grep dimensions | awk '{print $2}'`);
+      return `Screen ${stdout.trim()} captured`;
+    }
+  } catch {
+    return null;
+  }
+}