@projectservan8n/cnapse 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,55 +1,21 @@
 #!/usr/bin/env node
+import {
+  getApiKey,
+  getConfig,
+  setApiKey,
+  setModel,
+  setProvider
+} from "./chunk-COKO6V5J.js";
 
 // src/index.tsx
 import { render } from "ink";
 
 // src/components/App.tsx
-import { useState } from "react";
-import { Box as Box5, Text as Text5, useApp, useInput } from "ink";
+import { useState as useState2, useEffect, useRef } from "react";
+import { Box as Box6, Text as Text6, useApp, useInput as useInput2 } from "ink";
 
 // src/components/Header.tsx
 import { Box, Text } from "ink";
-
-// src/lib/config.ts
-import Conf from "conf";
-var config = new Conf({
-  projectName: "cnapse",
-  defaults: {
-    provider: "ollama",
-    model: "qwen2.5:0.5b",
-    apiKeys: {},
-    ollamaHost: "http://localhost:11434",
-    openrouter: {
-      siteUrl: "https://github.com/projectservan8n/C-napse",
-      appName: "C-napse"
-    }
-  }
-});
-function getConfig() {
-  return {
-    provider: config.get("provider"),
-    model: config.get("model"),
-    apiKeys: config.get("apiKeys"),
-    ollamaHost: config.get("ollamaHost"),
-    openrouter: config.get("openrouter")
-  };
-}
-function setProvider(provider) {
-  config.set("provider", provider);
-}
-function setModel(model) {
-  config.set("model", model);
-}
-function setApiKey(provider, key) {
-  const keys = config.get("apiKeys");
-  keys[provider] = key;
-  config.set("apiKeys", keys);
-}
-function getApiKey(provider) {
-  return config.get("apiKeys")[provider];
-}
-
-// src/components/Header.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var ASCII_BANNER = `
   \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
@@ -59,15 +25,18 @@ var ASCII_BANNER = `
  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `.trim();
-function Header() {
-  const config2 = getConfig();
+function Header({ screenWatch = false, telegramEnabled = false }) {
+  const config = getConfig();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ jsx(Text, { color: "cyan", children: ASCII_BANNER }),
     /* @__PURE__ */ jsx(Box, { justifyContent: "center", children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-      config2.provider,
+      config.provider,
       " \u2502 ",
-      config2.model
-    ] }) })
+      config.model,
+      screenWatch && /* @__PURE__ */ jsx(Text, { color: "yellow", children: " \u2502 \u{1F5A5}\uFE0F Screen" }),
+      telegramEnabled && /* @__PURE__ */ jsx(Text, { color: "blue", children: " \u2502 \u{1F4F1} Telegram" })
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { justifyContent: "center", children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Press Ctrl+H for help" }) })
   ] });
 }
 
@@ -129,6 +98,98 @@ function StatusBar({ status }) {
   return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { backgroundColor: "gray", color: "white", children: ` ${status} \u2502 Ctrl+C: Exit \u2502 Enter: Send ` }) });
 }
 
+// src/components/HelpMenu.tsx
+import React, { useState } from "react";
+import { Box as Box5, Text as Text5, useInput } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MENU_ITEMS = [
+  // Navigation
+  { command: "/help", shortcut: "Ctrl+H", description: "Show this help menu", category: "navigation" },
+  { command: "/clear", shortcut: "Ctrl+L", description: "Clear chat history", category: "navigation" },
+  { command: "/quit", shortcut: "Ctrl+C", description: "Exit C-napse", category: "navigation" },
+  // Actions
+  { command: "/screen", shortcut: "Ctrl+S", description: "Take screenshot and describe", category: "actions" },
+  { command: "/task", description: "Run multi-step task", category: "actions" },
+  { command: "/telegram", shortcut: "Ctrl+T", description: "Toggle Telegram bot", category: "actions" },
+  // Settings
+  { command: "/config", description: "Show/edit configuration", category: "settings" },
+  { command: "/watch", shortcut: "Ctrl+W", description: "Toggle screen watching", category: "settings" },
+  { command: "/model", description: "Change AI model", category: "settings" },
+  { command: "/provider", description: "Change AI provider", category: "settings" }
+];
+function HelpMenu({ onClose, onSelect }) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [selectedCategory, setSelectedCategory] = useState("all");
+  const filteredItems = selectedCategory === "all" ? MENU_ITEMS : MENU_ITEMS.filter((item) => item.category === selectedCategory);
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredItems.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < filteredItems.length - 1 ? prev + 1 : 0);
+    }
+    if (key.leftArrow || key.rightArrow) {
+      const categories2 = ["all", "navigation", "actions", "settings"];
+      const currentIdx = categories2.indexOf(selectedCategory);
+      if (key.leftArrow) {
+        setSelectedCategory(categories2[currentIdx > 0 ? currentIdx - 1 : categories2.length - 1]);
+      } else {
+        setSelectedCategory(categories2[currentIdx < categories2.length - 1 ? currentIdx + 1 : 0]);
+      }
+      setSelectedIndex(0);
+    }
+    if (key.return) {
+      const item = filteredItems[selectedIndex];
+      if (item) {
+        onSelect(item.command);
+        onClose();
+      }
+    }
+  });
+  const categories = [
+    { key: "all", label: "All" },
+    { key: "navigation", label: "Navigation" },
+    { key: "actions", label: "Actions" },
+    { key: "settings", label: "Settings" }
+  ];
+  return /* @__PURE__ */ jsxs4(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      padding: 1,
+      width: 60,
+      children: [
+        /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "C-napse Help" }) }),
+        /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: categories.map((cat, idx) => /* @__PURE__ */ jsxs4(React.Fragment, { children: [
+          /* @__PURE__ */ jsx5(
+            Text5,
+            {
+              color: selectedCategory === cat.key ? "cyan" : "gray",
+              bold: selectedCategory === cat.key,
+              children: cat.label
+            }
+          ),
+          idx < categories.length - 1 && /* @__PURE__ */ jsx5(Text5, { color: "gray", children: " \u2502 " })
+        ] }, cat.key)) }),
+        /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Use \u2190\u2192 to switch tabs, \u2191\u2193 to navigate, Enter to select" }) }),
+        /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: filteredItems.map((item, index) => /* @__PURE__ */ jsxs4(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: index === selectedIndex ? "cyan" : "white", children: index === selectedIndex ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsx5(Box5, { width: 12, children: /* @__PURE__ */ jsx5(Text5, { bold: index === selectedIndex, color: index === selectedIndex ? "cyan" : "white", children: item.command }) }),
+          item.shortcut && /* @__PURE__ */ jsx5(Box5, { width: 10, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", dimColor: true, children: item.shortcut }) }),
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: item.description })
+        ] }, item.command)) }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 1, justifyContent: "center", children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Press Esc to close" }) })
+      ]
+    }
+  );
+}
+
 // src/lib/api.ts
 var SYSTEM_PROMPT = `You are C-napse, a helpful AI assistant for PC automation running on the user's desktop.
 You can help with coding, file management, shell commands, and more. Be concise and helpful.
@@ -137,23 +198,23 @@ When responding:
 - Be direct and practical
 - Use markdown formatting for code blocks
 - If asked to do something, explain what you'll do first`;
-async function chat(messages) {
-  const config2 = getConfig();
+async function chat(messages, systemPrompt) {
+  const config = getConfig();
   const allMessages = [
-    { role: "system", content: SYSTEM_PROMPT },
+    { role: "system", content: systemPrompt || SYSTEM_PROMPT },
     ...messages
   ];
-  switch (config2.provider) {
+  switch (config.provider) {
     case "openrouter":
-      return chatOpenRouter(allMessages, config2.model);
+      return chatOpenRouter(allMessages, config.model);
     case "ollama":
-      return chatOllama(allMessages, config2.model);
+      return chatOllama(allMessages, config.model);
     case "anthropic":
-      return chatAnthropic(allMessages, config2.model);
+      return chatAnthropic(allMessages, config.model);
     case "openai":
-      return chatOpenAI(allMessages, config2.model);
+      return chatOpenAI(allMessages, config.model);
     default:
-      throw new Error(`Unknown provider: ${config2.provider}`);
+      throw new Error(`Unknown provider: ${config.provider}`);
   }
 }
 async function chatOpenRouter(messages, model) {
@@ -161,14 +222,14 @@ async function chatOpenRouter(messages, model) {
   if (!apiKey) {
     throw new Error("OpenRouter API key not configured. Run: cnapse auth openrouter <key>");
   }
-  const config2 = getConfig();
+  const config = getConfig();
   const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
     method: "POST",
     headers: {
       "Authorization": `Bearer ${apiKey}`,
       "Content-Type": "application/json",
-      "HTTP-Referer": config2.openrouter.siteUrl,
-      "X-Title": config2.openrouter.appName
+      "HTTP-Referer": config.openrouter.siteUrl,
+      "X-Title": config.openrouter.appName
     },
     body: JSON.stringify({
       model,
@@ -186,8 +247,8 @@ async function chatOpenRouter(messages, model) {
   return { content, model };
 }
 async function chatOllama(messages, model) {
-  const config2 = getConfig();
-  const response = await fetch(`${config2.ollamaHost}/api/chat`, {
+  const config = getConfig();
+  const response = await fetch(`${config.ollamaHost}/api/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -260,23 +321,904 @@ async function chatOpenAI(messages, model) {
   return { content, model };
 }
 
+// src/lib/screen.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function getScreenDescription() {
+  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;
+  }
+}
+
+// src/lib/vision.ts
+async function describeScreen() {
+  const screenshot = await captureScreenshot();
+  if (!screenshot) {
+    throw new Error("Failed to capture screenshot");
+  }
+  const config = getConfig();
+  const description = await analyzeWithVision(screenshot, config.provider);
+  return { description, screenshot };
+}
+async function captureScreenshot() {
+  try {
+    const screenshotDesktop = await import("screenshot-desktop");
+    const buffer = await screenshotDesktop.default({ format: "png" });
+    return buffer.toString("base64");
+  } catch {
+    return captureScreenFallback();
+  }
+}
+async function captureScreenFallback() {
+  const { exec: exec5 } = await import("child_process");
+  const { promisify: promisify5 } = await import("util");
+  const { tmpdir } = await import("os");
+  const { join } = await import("path");
+  const { readFile, unlink } = await import("fs/promises");
+  const execAsync5 = promisify5(exec5);
+  const tempFile = join(tmpdir(), `cnapse-screen-${Date.now()}.png`);
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      await execAsync5(`
+        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") {
+      await execAsync5(`screencapture -x "${tempFile}"`);
+    } else {
+      await execAsync5(`gnome-screenshot -f "${tempFile}" 2>/dev/null || scrot "${tempFile}" 2>/dev/null || import -window root "${tempFile}"`);
+    }
+    const imageBuffer = await readFile(tempFile);
+    await unlink(tempFile).catch(() => {
+    });
+    return imageBuffer.toString("base64");
+  } catch {
+    return null;
+  }
+}
+async function analyzeWithVision(base64Image, provider) {
+  const prompt = `Look at this screenshot and describe:
+1. What application or window is visible
+2. Key UI elements you can see (buttons, text fields, menus)
+3. What the user appears to be doing or could do next
+4. Any notable content or state
+
+Be concise but helpful.`;
+  switch (provider) {
+    case "ollama":
+      return analyzeWithOllama(base64Image, prompt);
+    case "openrouter":
+      return analyzeWithOpenRouter(base64Image, prompt);
+    case "anthropic":
+      return analyzeWithAnthropic(base64Image, prompt);
+    case "openai":
+      return analyzeWithOpenAI(base64Image, prompt);
+    default:
+      throw new Error(`Vision not supported for provider: ${provider}`);
+  }
+}
+async function analyzeWithOllama(base64Image, prompt) {
+  const config = getConfig();
+  const ollamaHost = config.ollamaHost || "http://localhost:11434";
+  const visionModels = ["llava", "llama3.2-vision", "bakllava", "llava-llama3"];
+  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
+  const response = await fetch(`${ollamaHost}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      prompt,
+      images: [base64Image],
+      stream: false
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Ollama vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.response || "Unable to analyze image";
+}
+async function analyzeWithOpenRouter(base64Image, prompt) {
+  const apiKey = getApiKey("openrouter");
+  if (!apiKey) throw new Error("OpenRouter API key not configured");
+  const model = "anthropic/claude-3-5-sonnet";
+  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://c-napse.up.railway.app",
+      "X-Title": "C-napse"
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            {
+              type: "image_url",
+              image_url: { url: `data:image/png;base64,${base64Image}` }
+            }
+          ]
+        }
+      ],
+      max_tokens: 1e3
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenRouter vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || "Unable to analyze image";
+}
+async function analyzeWithAnthropic(base64Image, prompt) {
+  const apiKey = getApiKey("anthropic");
+  if (!apiKey) throw new Error("Anthropic API key not configured");
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "claude-3-5-sonnet-20241022",
+      max_tokens: 1e3,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/png",
+                data: base64Image
+              }
+            },
+            { type: "text", text: prompt }
+          ]
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.content?.[0]?.text || "Unable to analyze image";
+}
+async function analyzeWithOpenAI(base64Image, prompt) {
+  const apiKey = getApiKey("openai");
+  if (!apiKey) throw new Error("OpenAI API key not configured");
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "gpt-4-vision-preview",
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            {
+              type: "image_url",
+              image_url: { url: `data:image/png;base64,${base64Image}` }
+            }
+          ]
+        }
+      ],
+      max_tokens: 1e3
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI vision error: ${text}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || "Unable to analyze image";
+}
+
+// src/services/telegram.ts
+import { EventEmitter } from "events";
+
+// src/tools/shell.ts
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+
+// src/tools/clipboard.ts
+import clipboardy from "clipboardy";
+
+// src/tools/process.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+
+// src/tools/computer.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+async function clickMouse(button = "left") {
+  try {
+    if (process.platform === "win32") {
+      const script = `
+Add-Type -MemberDefinition @"
+[DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
+public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
+"@ -Name Mouse -Namespace Win32
+${button === "left" ? "[Win32.Mouse]::mouse_event(0x02, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x04, 0, 0, 0, 0)" : button === "right" ? "[Win32.Mouse]::mouse_event(0x08, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x10, 0, 0, 0, 0)" : "[Win32.Mouse]::mouse_event(0x20, 0, 0, 0, 0); [Win32.Mouse]::mouse_event(0x40, 0, 0, 0, 0)"}`;
+      await execAsync3(`powershell -Command "${script.replace(/\n/g, " ")}"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      await execAsync3(`cliclick c:.`);
+    } else {
+      const btn = button === "left" ? "1" : button === "right" ? "3" : "2";
+      await execAsync3(`xdotool click ${btn}`);
+    }
+    return ok(`Clicked ${button} button`);
+  } catch (error) {
+    return err(`Failed to click: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function typeText(text) {
+  try {
+    if (process.platform === "win32") {
+      const escapedText = text.replace(/'/g, "''").replace(/[+^%~(){}[\]]/g, "{$&}");
+      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${escapedText}')"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      const escaped = text.replace(/'/g, "'\\''");
+      await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${escaped}"'`);
+    } else {
+      const escaped = text.replace(/'/g, "'\\''");
+      await execAsync3(`xdotool type '${escaped}'`);
+    }
+    return ok(`Typed: ${text}`);
+  } catch (error) {
+    return err(`Failed to type: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function pressKey(key) {
+  try {
+    if (process.platform === "win32") {
+      const winKeyMap = {
+        "enter": "{ENTER}",
+        "return": "{ENTER}",
+        "escape": "{ESC}",
+        "esc": "{ESC}",
+        "tab": "{TAB}",
+        "space": " ",
+        "backspace": "{BACKSPACE}",
+        "delete": "{DELETE}",
+        "up": "{UP}",
+        "down": "{DOWN}",
+        "left": "{LEFT}",
+        "right": "{RIGHT}",
+        "home": "{HOME}",
+        "end": "{END}",
+        "pageup": "{PGUP}",
+        "pagedown": "{PGDN}",
+        "f1": "{F1}",
+        "f2": "{F2}",
+        "f3": "{F3}",
+        "f4": "{F4}",
+        "f5": "{F5}",
+        "f6": "{F6}",
+        "f7": "{F7}",
+        "f8": "{F8}",
+        "f9": "{F9}",
+        "f10": "{F10}",
+        "f11": "{F11}",
+        "f12": "{F12}"
+      };
+      const winKey = winKeyMap[key.toLowerCase()] || key;
+      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${winKey}')"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      const macKeyMap = {
+        "return": 36,
+        "enter": 36,
+        "escape": 53,
+        "esc": 53,
+        "tab": 48,
+        "space": 49,
+        "backspace": 51,
+        "delete": 117,
+        "up": 126,
+        "down": 125,
+        "left": 123,
+        "right": 124
+      };
+      const keyCode = macKeyMap[key.toLowerCase()];
+      if (keyCode) {
+        await execAsync3(`osascript -e 'tell application "System Events" to key code ${keyCode}'`);
+      } else {
+        await execAsync3(`osascript -e 'tell application "System Events" to keystroke "${key}"'`);
+      }
+    } else {
+      await execAsync3(`xdotool key ${key}`);
+    }
+    return ok(`Pressed: ${key}`);
+  } catch (error) {
+    return err(`Failed to press key: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function keyCombo(keys) {
+  try {
+    if (process.platform === "win32") {
+      const hasWin = keys.some((k) => k.toLowerCase() === "meta" || k.toLowerCase() === "win");
+      const hasR = keys.some((k) => k.toLowerCase() === "r");
+      if (hasWin && hasR) {
+        await execAsync3(`powershell -Command "$shell = New-Object -ComObject WScript.Shell; $shell.Run('explorer shell:::{2559a1f3-21d7-11d4-bdaf-00c04f60b9f0}')"`, { shell: "cmd.exe" });
+        return ok(`Pressed: ${keys.join("+")}`);
+      }
+      const modifierMap = {
+        "control": "^",
+        "ctrl": "^",
+        "alt": "%",
+        "shift": "+"
+      };
+      let combo = "";
+      const regularKeys = [];
+      for (const key of keys) {
+        const lower = key.toLowerCase();
+        if (modifierMap[lower]) {
+          combo += modifierMap[lower];
+        } else if (lower !== "meta" && lower !== "win") {
+          regularKeys.push(key.toLowerCase());
+        }
+      }
+      combo += regularKeys.join("");
+      await execAsync3(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${combo}')"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      const modifiers = keys.filter((k) => ["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
+      const regular = keys.filter((k) => !["control", "ctrl", "alt", "shift", "command", "meta"].includes(k.toLowerCase()));
+      let cmd = 'tell application "System Events" to keystroke "' + regular.join("") + '"';
+      if (modifiers.length > 0) {
+        const modMap = {
+          "control": "control down",
+          "ctrl": "control down",
+          "alt": "option down",
+          "shift": "shift down",
+          "command": "command down",
+          "meta": "command down"
+        };
+        cmd += " using {" + modifiers.map((m) => modMap[m.toLowerCase()]).join(", ") + "}";
+      }
+      await execAsync3(`osascript -e '${cmd}'`);
+    } else {
+      await execAsync3(`xdotool key ${keys.join("+")}`);
+    }
+    return ok(`Pressed: ${keys.join("+")}`);
+  } catch (error) {
+    return err(`Failed to press combo: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function focusWindow(title) {
+  try {
+    if (process.platform === "win32") {
+      const escaped = title.replace(/'/g, "''");
+      await execAsync3(`powershell -Command "$wshell = New-Object -ComObject wscript.shell; $wshell.AppActivate('${escaped}')"`, { shell: "cmd.exe" });
+    } else if (process.platform === "darwin") {
+      await execAsync3(`osascript -e 'tell application "${title}" to activate'`);
+    } else {
+      await execAsync3(`wmctrl -a "${title}"`);
+    }
+    return ok(`Focused window: ${title}`);
+  } catch (error) {
+    return err(`Failed to focus window: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/tools/index.ts
+function ok(output) {
+  return { success: true, output };
+}
+function err(error) {
+  return { success: false, output: "", error };
+}
+
+// src/tools/shell.ts
+var execAsync4 = promisify4(exec4);
+async function runCommand(cmd, timeout = 3e4) {
+  try {
+    const isWindows = process.platform === "win32";
+    const shell = isWindows ? "cmd.exe" : "/bin/sh";
+    const shellArg = isWindows ? "/C" : "-c";
+    const { stdout, stderr } = await execAsync4(cmd, {
+      shell,
+      timeout,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    });
+    if (stderr && stderr.trim()) {
+      return ok(`${stdout}
+[stderr]: ${stderr}`);
+    }
+    return ok(stdout || "(no output)");
+  } catch (error) {
+    if (error.killed) {
+      return err(`Command timed out after ${timeout}ms`);
+    }
+    const stderr = error.stderr || "";
+    const stdout = error.stdout || "";
+    return {
+      success: false,
+      output: stdout,
+      error: `Exit code: ${error.code || -1}
+${stderr}`
+    };
+  }
+}
+
+// src/services/telegram.ts
+var TelegramBotService = class extends EventEmitter {
+  bot = null;
+  isRunning = false;
+  allowedChatIds = /* @__PURE__ */ new Set();
+  constructor() {
+    super();
+  }
+  /**
+   * Start the Telegram bot
+   */
+  async start() {
+    if (this.isRunning) {
+      return;
+    }
+    const botToken = getApiKey("telegram");
+    if (!botToken) {
+      throw new Error("Telegram bot token not configured. Use: cnapse auth telegram YOUR_BOT_TOKEN");
+    }
+    try {
+      const { Telegraf } = await import("telegraf");
+      this.bot = new Telegraf(botToken);
+      const config = getConfig();
+      if (config.telegram?.chatId) {
+        this.allowedChatIds.add(config.telegram.chatId);
+      }
+      this.setupHandlers();
+      await this.bot.launch();
+      this.isRunning = true;
+      this.emit("started");
+    } catch (error) {
+      throw new Error(`Failed to start Telegram bot: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Stop the Telegram bot
+   */
+  async stop() {
+    if (!this.isRunning || !this.bot) {
+      return;
+    }
+    this.bot.stop("SIGTERM");
+    this.isRunning = false;
+    this.bot = null;
+    this.emit("stopped");
+  }
+  /**
+   * Check if bot is running
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Setup message and command handlers
+   */
+  setupHandlers() {
+    if (!this.bot) return;
+    this.bot.command("start", async (ctx) => {
+      const chatId = ctx.chat.id;
+      this.allowedChatIds.add(chatId);
+      await ctx.reply(
+        `\u{1F916} C-napse connected!
+
+Commands:
+/screen - Take screenshot
+/describe - Screenshot + AI description
+/run <cmd> - Execute command
+/status - System status
+
+Your chat ID: ${chatId}`
+      );
+    });
+    this.bot.command("screen", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F4F8} Taking screenshot...");
+      try {
+        const screenshot = await captureScreenshot();
+        if (!screenshot) {
+          await ctx.reply("\u274C Failed to capture screenshot");
+          return;
+        }
+        const buffer = Buffer.from(screenshot, "base64");
+        await ctx.replyWithPhoto({ source: buffer }, { caption: "\u{1F4F8} Current screen" });
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("describe", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      await ctx.reply("\u{1F50D} Analyzing screen...");
+      try {
+        const result = await describeScreen();
+        const buffer = Buffer.from(result.screenshot, "base64");
+        const caption = `\u{1F5A5}\uFE0F Screen Analysis:
+
+${result.description}`.slice(0, 1024);
+        await ctx.replyWithPhoto({ source: buffer }, { caption });
+        if (result.description.length > 900) {
+          await ctx.reply(result.description);
+        }
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("run", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const cmd = ctx.message.text.replace("/run ", "").trim();
+      if (!cmd) {
+        await ctx.reply("Usage: /run <command>\nExample: /run dir");
+        return;
+      }
+      await ctx.reply(`\u2699\uFE0F Running: ${cmd}`);
+      try {
+        const result = await runCommand(cmd, 3e4);
+        if (result.success) {
+          const output = result.output.slice(0, 4e3) || "(no output)";
+          await ctx.reply(`\u2705 Output:
+\`\`\`
+${output}
+\`\`\``, { parse_mode: "Markdown" });
+        } else {
+          await ctx.reply(`\u274C Error:
+\`\`\`
+${result.error}
+\`\`\``, { parse_mode: "Markdown" });
+        }
+      } catch (error) {
+        await ctx.reply(`\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
+    this.bot.command("status", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        await ctx.reply("\u26D4 Not authorized. Send /start first.");
+        return;
+      }
+      const config = getConfig();
+      const status = [
+        "\u{1F4CA} C-napse Status",
+        "",
+        `Provider: ${config.provider}`,
+        `Model: ${config.model}`,
+        `Platform: ${process.platform}`,
+        `Node: ${process.version}`
+      ].join("\n");
+      await ctx.reply(status);
+    });
+    this.bot.on("text", async (ctx) => {
+      if (!this.isAllowed(ctx.chat.id)) {
+        return;
+      }
+      if (ctx.message.text.startsWith("/")) {
+        return;
+      }
+      const message = {
+        chatId: ctx.chat.id,
+        text: ctx.message.text,
+        from: ctx.from.username || ctx.from.first_name || "User"
+      };
+      this.emit("message", message);
+      this.emit("command", "chat", ctx.message.text, ctx.chat.id);
+    });
+    this.bot.catch((err2) => {
+      this.emit("error", err2);
+    });
+  }
+  /**
+   * Check if chat is authorized
+   */
+  isAllowed(chatId) {
+    if (this.allowedChatIds.size === 0) {
+      return true;
+    }
+    return this.allowedChatIds.has(chatId);
+  }
+  /**
+   * Send a message to a specific chat
+   */
+  async sendMessage(chatId, text) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
+    }
+    await this.bot.telegram.sendMessage(chatId, text);
+  }
+  /**
+   * Send a photo to a specific chat
+   */
+  async sendPhoto(chatId, base64Image, caption) {
+    if (!this.bot || !this.isRunning) {
+      throw new Error("Telegram bot is not running");
+    }
+    const buffer = Buffer.from(base64Image, "base64");
+    await this.bot.telegram.sendPhoto(chatId, { source: buffer }, { caption });
+  }
+};
+var instance = null;
+function getTelegramBot() {
+  if (!instance) {
+    instance = new TelegramBotService();
+  }
+  return instance;
+}
+
+// src/lib/tasks.ts
+async function parseTask(input) {
+  const systemPrompt = `You are a task parser for PC automation. Convert user requests into specific, executable steps.
+
+Available actions:
+- open_app: Open an application (e.g., "open_app:notepad", "open_app:vscode")
+- type_text: Type text (e.g., "type_text:Hello World")
+- press_key: Press a key (e.g., "press_key:enter", "press_key:escape")
+- key_combo: Key combination (e.g., "key_combo:control+s", "key_combo:alt+f4")
+- click: Click mouse (e.g., "click:left", "click:right")
+- wait: Wait seconds (e.g., "wait:2")
+- focus_window: Focus window by title (e.g., "focus_window:Notepad")
+- screenshot: Take screenshot and describe
+
+Respond ONLY with a JSON array of steps, no other text:
+[
+  { "description": "Human readable step", "action": "action_type:params" },
+  ...
+]
+
+Example input: "open notepad and type hello world"
+Example output:
+[
+  { "description": "Open Notepad", "action": "open_app:notepad" },
+  { "description": "Wait for Notepad to open", "action": "wait:2" },
+  { "description": "Type hello world", "action": "type_text:Hello World" }
+]
+
+Example input: "open vscode, go to folder E:\\Projects, then open terminal"
+Example output:
+[
+  { "description": "Open VS Code", "action": "open_app:code" },
+  { "description": "Wait for VS Code to load", "action": "wait:3" },
+  { "description": "Open folder with Ctrl+K Ctrl+O", "action": "key_combo:control+k" },
+  { "description": "Wait for dialog", "action": "wait:1" },
+  { "description": "Continue folder open", "action": "key_combo:control+o" },
+  { "description": "Wait for folder dialog", "action": "wait:1" },
+  { "description": "Type folder path", "action": "type_text:E:\\\\Projects" },
+  { "description": "Press Enter to open folder", "action": "press_key:enter" },
+  { "description": "Wait for folder to load", "action": "wait:2" },
+  { "description": "Open terminal with Ctrl+\`", "action": "key_combo:control+\`" }
+]`;
+  const messages = [
+    { role: "user", content: input }
+  ];
+  try {
+    const response = await chat(messages, systemPrompt);
+    const content = response.content || "[]";
+    const jsonMatch = content.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      throw new Error("Failed to parse task steps");
+    }
+    const parsedSteps = JSON.parse(jsonMatch[0]);
+    const steps = parsedSteps.map((step, index) => ({
+      id: `step-${index + 1}`,
+      description: step.description,
+      action: step.action,
+      status: "pending"
+    }));
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps,
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  } catch (error) {
+    return {
+      id: `task-${Date.now()}`,
+      description: input,
+      steps: [{
+        id: "step-1",
+        description: input,
+        action: `chat:${input}`,
+        status: "pending"
+      }],
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+async function executeStep(step) {
+  const [actionType, ...paramParts] = step.action.split(":");
+  const params = paramParts.join(":");
+  switch (actionType) {
+    case "open_app":
+      await keyCombo(["meta", "r"]);
+      await sleep(500);
+      await typeText(params);
+      await sleep(300);
+      await pressKey("Return");
+      step.result = `Opened ${params}`;
+      break;
+    case "type_text":
+      await typeText(params);
+      step.result = `Typed: ${params}`;
+      break;
+    case "press_key":
+      await pressKey(params);
+      step.result = `Pressed ${params}`;
+      break;
+    case "key_combo":
+      const keys = params.split("+").map((k) => k.trim());
+      await keyCombo(keys);
+      step.result = `Pressed ${params}`;
+      break;
+    case "click":
+      const button = params || "left";
+      await clickMouse(button);
+      step.result = `Clicked ${button}`;
+      break;
+    case "wait":
+      const seconds = parseInt(params) || 1;
+      await sleep(seconds * 1e3);
+      step.result = `Waited ${seconds}s`;
+      break;
+    case "focus_window":
+      await focusWindow(params);
+      step.result = `Focused window: ${params}`;
+      break;
+    case "screenshot":
+      const vision = await describeScreen();
+      step.result = vision.description;
+      break;
+    case "chat":
+      step.result = `Task noted: ${params}`;
+      break;
+    default:
+      throw new Error(`Unknown action: ${actionType}`);
+  }
+}
+async function executeTask(task, onProgress) {
+  task.status = "running";
+  for (const step of task.steps) {
+    if (task.status === "failed") {
+      step.status = "skipped";
+      continue;
+    }
+    step.status = "running";
+    onProgress?.(task, step);
+    try {
+      await executeStep(step);
+      step.status = "completed";
+    } catch (error) {
+      step.status = "failed";
+      step.error = error instanceof Error ? error.message : "Unknown error";
+      task.status = "failed";
+    }
+    onProgress?.(task, step);
+  }
+  if (task.status !== "failed") {
+    task.status = "completed";
+  }
+  task.completedAt = /* @__PURE__ */ new Date();
+  return task;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatTask(task) {
+  const statusEmoji = {
+    pending: "\u23F3",
+    running: "\u{1F504}",
+    completed: "\u2705",
+    failed: "\u274C"
+  };
+  const stepStatusEmoji = {
+    pending: "\u25CB",
+    running: "\u25D0",
+    completed: "\u25CF",
+    failed: "\u2717",
+    skipped: "\u25CC"
+  };
+  let output = `${statusEmoji[task.status]} Task: ${task.description}
+
+`;
+  for (const step of task.steps) {
+    output += `  ${stepStatusEmoji[step.status]} ${step.description}`;
+    if (step.result) {
+      output += ` \u2192 ${step.result}`;
+    }
+    if (step.error) {
+      output += ` (Error: ${step.error})`;
+    }
+    output += "\n";
+  }
+  return output;
+}
+
 // src/components/App.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function App() {
   const { exit } = useApp();
-  const [messages, setMessages] = useState([
+  const [messages, setMessages] = useState2([
     {
       id: "0",
       role: "system",
-      content: "Welcome to C-napse! Type your message and press Enter.\n\nShortcuts:\n  Ctrl+C - Exit\n  /clear - Clear chat\n  /help  - Show help",
+      content: "Welcome to C-napse! Type your message and press Enter.\n\nShortcuts:\n  Ctrl+C - Exit\n  Ctrl+W - Toggle screen watch\n  /clear - Clear chat\n  /help  - Show help",
       timestamp: /* @__PURE__ */ new Date()
     }
   ]);
-  const [input, setInput] = useState("");
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [status, setStatus] = useState("Ready");
-  const [error, setError] = useState(null);
-  useInput((inputChar, key) => {
+  const [input, setInput] = useState2("");
+  const [isProcessing, setIsProcessing] = useState2(false);
+  const [status, setStatus] = useState2("Ready");
+  const [error, setError] = useState2(null);
+  const [screenWatch, setScreenWatch] = useState2(false);
+  const [showHelpMenu, setShowHelpMenu] = useState2(false);
+  const [telegramEnabled, setTelegramEnabled] = useState2(false);
+  const screenContextRef = useRef(null);
+  useEffect(() => {
+    if (!screenWatch) {
+      screenContextRef.current = null;
+      return;
+    }
+    const checkScreen = async () => {
+      const desc = await getScreenDescription();
+      if (desc) {
+        screenContextRef.current = desc;
+      }
+    };
+    checkScreen();
+    const interval = setInterval(checkScreen, 5e3);
+    return () => clearInterval(interval);
+  }, [screenWatch]);
+  useInput2((inputChar, key) => {
+    if (showHelpMenu) {
+      return;
+    }
     if (key.ctrl && inputChar === "c") {
       exit();
     }
@@ -284,6 +1226,27 @@ function App() {
       setMessages([messages[0]]);
       setError(null);
     }
+    if (key.ctrl && inputChar === "w") {
+      setScreenWatch((prev) => {
+        const newState = !prev;
+        addSystemMessage(
+          newState ? "\u{1F5A5}\uFE0F Screen watching enabled. AI will have context of your screen." : "\u{1F5A5}\uFE0F Screen watching disabled."
+        );
+        return newState;
+      });
+    }
+    if (key.ctrl && inputChar === "h") {
+      setShowHelpMenu(true);
+    }
+    if (key.ctrl && inputChar === "t") {
+      setTelegramEnabled((prev) => {
+        const newState = !prev;
+        addSystemMessage(
+          newState ? "\u{1F4F1} Telegram bot enabled." : "\u{1F4F1} Telegram bot disabled."
+        );
+        return newState;
+      });
+    }
   });
   const handleSubmit = async (value) => {
     if (!value.trim() || isProcessing) return;
@@ -316,15 +1279,21 @@ function App() {
     setStatus("Thinking...");
     try {
       const apiMessages = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-10).map((m) => ({ role: m.role, content: m.content }));
-      apiMessages.push({ role: "user", content: userInput });
+      let finalInput = userInput;
+      if (screenWatch && screenContextRef.current) {
+        finalInput = `[Screen context: ${screenContextRef.current}]
+
+${userInput}`;
+      }
+      apiMessages.push({ role: "user", content: finalInput });
       const response = await chat(apiMessages);
       setMessages(
         (prev) => prev.map(
           (m) => m.id === assistantId ? { ...m, content: response.content || "(no response)", isStreaming: false } : m
         )
       );
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : "Unknown error";
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Unknown error";
       setError(errorMsg);
       setMessages(
         (prev) => prev.map(
@@ -339,18 +1308,137 @@ function App() {
   const handleCommand = (cmd) => {
     const parts = cmd.slice(1).split(" ");
     const command = parts[0];
+    const args2 = parts.slice(1).join(" ");
     switch (command) {
       case "clear":
         setMessages([messages[0]]);
         addSystemMessage("Chat cleared.");
         break;
       case "help":
-        addSystemMessage(
-          "Commands:\n  /clear - Clear chat history\n  /help  - Show this help\n\nJust type naturally to chat with the AI!"
-        );
+        setShowHelpMenu(true);
+        break;
+      case "watch":
+        setScreenWatch((prev) => {
+          const newState = !prev;
+          addSystemMessage(
+            newState ? "\u{1F5A5}\uFE0F Screen watching enabled." : "\u{1F5A5}\uFE0F Screen watching disabled."
+          );
+          return newState;
+        });
+        break;
+      case "telegram":
+        handleTelegramToggle();
+        break;
+      case "screen":
+        handleScreenCommand();
+        break;
+      case "task":
+        if (args2) {
+          handleTaskCommand(args2);
+        } else {
+          addSystemMessage("Usage: /task <description>\nExample: /task open notepad and type hello");
+        }
+        break;
+      case "config":
+        addSystemMessage("\u2699\uFE0F Configuration:\n  Provider: Use cnapse config\n  Model: Use cnapse config set model <name>");
+        break;
+      case "model":
+        addSystemMessage("\u{1F916} Model selection coming soon.\nUse: cnapse config set model <name>");
+        break;
+      case "provider":
+        addSystemMessage("\u{1F50C} Provider selection coming soon.\nUse: cnapse config set provider <name>");
+        break;
+      case "quit":
+      case "exit":
+        exit();
         break;
       default:
-        addSystemMessage(`Unknown command: ${command}`);
+        addSystemMessage(`Unknown command: ${command}
+Type /help to see available commands.`);
+    }
+  };
+  const handleHelpMenuSelect = (command) => {
+    handleCommand(command);
+  };
+  const handleScreenCommand = async () => {
+    addSystemMessage("\u{1F4F8} Taking screenshot and analyzing...");
+    setStatus("Analyzing screen...");
+    setIsProcessing(true);
+    try {
+      const result = await describeScreen();
+      addSystemMessage(`\u{1F5A5}\uFE0F Screen Analysis:
+
+${result.description}`);
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Vision analysis failed";
+      addSystemMessage(`\u274C Screen capture failed: ${errorMsg}`);
+    } finally {
+      setIsProcessing(false);
+      setStatus("Ready");
+    }
+  };
+  const handleTaskCommand = async (taskDescription) => {
+    addSystemMessage(`\u{1F4CB} Parsing task: ${taskDescription}`);
+    setStatus("Parsing task...");
+    setIsProcessing(true);
+    try {
+      const task = await parseTask(taskDescription);
+      addSystemMessage(`\u{1F4CB} Task planned (${task.steps.length} steps):
+${formatTask(task)}`);
+      addSystemMessage("\u{1F680} Executing task...");
+      setStatus("Executing task...");
+      await executeTask(task, (updatedTask, currentStep) => {
+        if (currentStep.status === "running") {
+          setStatus(`Running: ${currentStep.description}`);
+        }
+      });
+      addSystemMessage(`
+${formatTask(task)}`);
+      if (task.status === "completed") {
+        addSystemMessage("\u2705 Task completed successfully!");
+      } else {
+        addSystemMessage("\u274C Task failed. Check the steps above for errors.");
+      }
+    } catch (err2) {
+      const errorMsg = err2 instanceof Error ? err2.message : "Task failed";
+      addSystemMessage(`\u274C Task error: ${errorMsg}`);
+    } finally {
+      setIsProcessing(false);
+      setStatus("Ready");
+    }
+  };
+  const handleTelegramToggle = async () => {
+    const bot = getTelegramBot();
+    if (telegramEnabled) {
+      try {
+        await bot.stop();
+        setTelegramEnabled(false);
+        addSystemMessage("\u{1F4F1} Telegram bot stopped.");
+      } catch (err2) {
+        const errorMsg = err2 instanceof Error ? err2.message : "Failed to stop bot";
+        addSystemMessage(`\u274C Error stopping bot: ${errorMsg}`);
+      }
+    } else {
+      addSystemMessage("\u{1F4F1} Starting Telegram bot...");
+      setStatus("Starting Telegram...");
+      try {
+        bot.on("message", (msg) => {
+          addSystemMessage(`\u{1F4F1} Telegram [${msg.from}]: ${msg.text}`);
+        });
+        bot.on("error", (error2) => {
+          addSystemMessage(`\u{1F4F1} Telegram error: ${error2.message}`);
+        });
+        await bot.start();
+        setTelegramEnabled(true);
+        addSystemMessage(
+          "\u{1F4F1} Telegram bot started!\n\nOpen Telegram and send /start to your bot to connect.\nCommands: /screen, /describe, /run <cmd>, /status"
+        );
+      } catch (err2) {
+        const errorMsg = err2 instanceof Error ? err2.message : "Failed to start bot";
+        addSystemMessage(`\u274C Telegram error: ${errorMsg}`);
+      } finally {
+        setStatus("Ready");
+      }
     }
   };
   const addSystemMessage = (content) => {
@@ -365,11 +1453,20 @@ function App() {
     ]);
   };
   const visibleMessages = messages.slice(-20);
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", height: "100%", children: [
-    /* @__PURE__ */ jsx5(Header, {}),
-    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "gray", padding: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "gray", children: " Chat " }),
-      visibleMessages.map((msg) => /* @__PURE__ */ jsx5(
+  if (showHelpMenu) {
+    return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", height: "100%", alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx6(
+      HelpMenu,
+      {
+        onClose: () => setShowHelpMenu(false),
+        onSelect: handleHelpMenuSelect
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx6(Header, { screenWatch, telegramEnabled }),
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "gray", padding: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "gray", children: " Chat " }),
+      visibleMessages.map((msg) => /* @__PURE__ */ jsx6(
         ChatMessage,
         {
           role: msg.role,
@@ -380,11 +1477,11 @@ function App() {
         msg.id
       ))
     ] }),
-    error && /* @__PURE__ */ jsx5(Box5, { marginY: 1, children: /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
+    error && /* @__PURE__ */ jsx6(Box6, { marginY: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: "red", children: [
       "Error: ",
       error
     ] }) }),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
       ChatInput,
       {
         value: input,
@@ -393,12 +1490,12 @@ function App() {
         isProcessing
       }
     ),
-    /* @__PURE__ */ jsx5(StatusBar, { status })
+    /* @__PURE__ */ jsx6(StatusBar, { status })
   ] });
 }
 
 // src/index.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var args = process.argv.slice(2);
 if (args.length > 0) {
   const command = args[0];
@@ -441,15 +1538,15 @@ if (args.length > 0) {
         process.exit(0);
       }
       if (subcommand === "show" || !subcommand) {
-        const config2 = getConfig();
+        const config = getConfig();
         console.log("\nC-napse Configuration:");
-        console.log(`  Provider: ${config2.provider}`);
-        console.log(`  Model: ${config2.model}`);
-        console.log(`  Ollama Host: ${config2.ollamaHost}`);
+        console.log(`  Provider: ${config.provider}`);
+        console.log(`  Model: ${config.model}`);
+        console.log(`  Ollama Host: ${config.ollamaHost}`);
         console.log(`  API Keys configured:`);
-        console.log(`    - OpenRouter: ${config2.apiKeys.openrouter ? "\u2713" : "\u2717"}`);
-        console.log(`    - Anthropic: ${config2.apiKeys.anthropic ? "\u2713" : "\u2717"}`);
-        console.log(`    - OpenAI: ${config2.apiKeys.openai ? "\u2713" : "\u2717"}`);
+        console.log(`    - OpenRouter: ${config.apiKeys.openrouter ? "\u2713" : "\u2717"}`);
+        console.log(`    - Anthropic: ${config.apiKeys.anthropic ? "\u2713" : "\u2717"}`);
+        console.log(`    - OpenAI: ${config.apiKeys.openai ? "\u2713" : "\u2717"}`);
         console.log("");
         process.exit(0);
       }
@@ -464,18 +1561,22 @@ C-napse - Autonomous PC Intelligence
 
 Usage:
   cnapse                     Start interactive chat
+  cnapse init                Interactive setup wizard
   cnapse auth <provider> <key>  Set API key
   cnapse config              Show configuration
   cnapse config set <k> <v>  Set config value
   cnapse help                Show this help
 
 Providers:
-  ollama      - Local AI (default)
-  openrouter  - OpenRouter API
+  ollama      - Local AI (default, free)
+  openrouter  - OpenRouter API (many models)
   anthropic   - Anthropic Claude
   openai      - OpenAI GPT
 
-Examples:
+Quick Start:
+  cnapse init                # Interactive setup
+
+Manual Setup:
   cnapse auth openrouter sk-or-xxxxx
   cnapse config set provider openrouter
   cnapse config set model qwen/qwen-2.5-coder-32b-instruct
@@ -488,9 +1589,14 @@ Examples:
       console.log("cnapse v0.2.0");
       process.exit(0);
     }
+    case "init": {
+      const { Setup } = await import("./Setup-Q32JPHGP.js");
+      render(/* @__PURE__ */ jsx7(Setup, {}));
+      process.exit(0);
+    }
     default: {
       break;
     }
   }
 }
-render(/* @__PURE__ */ jsx6(App, {}));
+render(/* @__PURE__ */ jsx7(App, {}));