@projectservan8n/cnapse 0.9.0 → 0.10.0

package/dist/chunk-GP73OJCZ.js

@@ -0,0 +1,377 @@
+import {
+  getApiKey,
+  getConfig
+} from "./chunk-COKO6V5J.js";
+
+// src/lib/system.ts
+import os from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var cachedSystemInfo = null;
+async function getSystemInfo() {
+  if (cachedSystemInfo) return cachedSystemInfo;
+  const platform = os.platform();
+  const cpus = os.cpus();
+  let osName = platform;
+  const osVersion = os.release();
+  if (platform === "win32") {
+    try {
+      const { stdout } = await execAsync("wmic os get Caption /value", { timeout: 5e3 });
+      const match = stdout.match(/Caption=(.+)/);
+      if (match) osName = match[1].trim();
+    } catch {
+      osName = `Windows ${osVersion}`;
+    }
+  } else if (platform === "darwin") {
+    try {
+      const { stdout } = await execAsync("sw_vers -productName && sw_vers -productVersion", { timeout: 5e3 });
+      const lines = stdout.trim().split("\n");
+      osName = `${lines[0]} ${lines[1]}`;
+    } catch {
+      osName = `macOS ${osVersion}`;
+    }
+  } else if (platform === "linux") {
+    try {
+      const { stdout } = await execAsync("cat /etc/os-release | grep PRETTY_NAME", { timeout: 5e3 });
+      const match = stdout.match(/PRETTY_NAME="(.+)"/);
+      if (match) osName = match[1];
+    } catch {
+      osName = `Linux ${osVersion}`;
+    }
+  }
+  cachedSystemInfo = {
+    platform,
+    osName,
+    osVersion,
+    arch: os.arch(),
+    cpuModel: cpus[0]?.model || "Unknown CPU",
+    cpuCores: cpus.length,
+    totalMemoryGB: Math.round(os.totalmem() / 1024 ** 3 * 10) / 10,
+    freeMemoryGB: Math.round(os.freemem() / 1024 ** 3 * 10) / 10,
+    username: os.userInfo().username,
+    hostname: os.hostname(),
+    homeDir: os.homedir(),
+    shell: process.env.SHELL || process.env.COMSPEC || "unknown"
+  };
+  return cachedSystemInfo;
+}
+async function getSystemContext() {
+  const info = await getSystemInfo();
+  return `SYSTEM INFO:
+- OS: ${info.osName} (${info.arch})
+- CPU: ${info.cpuModel} (${info.cpuCores} cores)
+- RAM: ${info.totalMemoryGB}GB total, ${info.freeMemoryGB}GB free
+- User: ${info.username}@${info.hostname}
+- Home: ${info.homeDir}
+- Shell: ${info.shell}`;
+}
+function getCwd() {
+  return process.cwd();
+}
+
+// src/lib/api.ts
+var BASE_PROMPT = `You are C-napse, an AI assistant for PC automation running on the user's desktop.
+You have access to their system and can help with coding, file management, shell commands, and more.
+
+When responding:
+- Be direct and practical
+- Use markdown formatting for code blocks
+- If asked to do something, explain what you'll do first
+- Give commands specific to the user's OS (use the system info below)
+- Be aware of the user's current working directory`;
+var systemContextCache = null;
+async function getSystemPrompt() {
+  if (!systemContextCache) {
+    systemContextCache = await getSystemContext();
+  }
+  const cwd = getCwd();
+  return `${BASE_PROMPT}
+
+${systemContextCache}
+- Current directory: ${cwd}`;
+}
+async function chat(messages, systemPrompt) {
+  const config = getConfig();
+  const finalPrompt = systemPrompt || await getSystemPrompt();
+  const allMessages = [
+    { role: "system", content: finalPrompt },
+    ...messages
+  ];
+  switch (config.provider) {
+    case "openrouter":
+      return chatOpenRouter(allMessages, config.model);
+    case "ollama":
+      return chatOllama(allMessages, config.model);
+    case "anthropic":
+      return chatAnthropic(allMessages, config.model);
+    case "openai":
+      return chatOpenAI(allMessages, config.model);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+async function chatOpenRouter(messages, model) {
+  const apiKey = getApiKey("openrouter");
+  if (!apiKey) {
+    throw new Error("OpenRouter API key not configured. Run: cnapse auth openrouter <key>");
+  }
+  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": config.openrouter.siteUrl,
+      "X-Title": config.openrouter.appName
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      max_tokens: 2048,
+      temperature: 0.7
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenRouter error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  const content = data.choices?.[0]?.message?.content || "";
+  return { content, model };
+}
+async function chatOllama(messages, model) {
+  const config = getConfig();
+  const response = await fetch(`${config.ollamaHost}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: false
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Ollama error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  const content = data.message?.content || "";
+  return { content, model };
+}
+async function chatAnthropic(messages, model) {
+  const apiKey = getApiKey("anthropic");
+  if (!apiKey) {
+    throw new Error("Anthropic API key not configured. Run: cnapse auth anthropic <key>");
+  }
+  const systemMsg = messages.find((m) => m.role === "system");
+  const chatMessages = messages.filter((m) => m.role !== "system");
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 2048,
+      system: systemMsg?.content || "",
+      messages: chatMessages
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  const content = data.content?.[0]?.text || "";
+  return { content, model };
+}
+async function chatOpenAI(messages, model) {
+  const apiKey = getApiKey("openai");
+  if (!apiKey) {
+    throw new Error("OpenAI API key not configured. Run: cnapse auth openai <key>");
+  }
+  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,
+      messages,
+      max_tokens: 2048,
+      temperature: 0.7
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  const content = data.choices?.[0]?.message?.content || "";
+  return { content, model };
+}
+async function chatWithVision(messages, screenshotBase64) {
+  const config = getConfig();
+  const systemPrompt = await getSystemPrompt();
+  const visionPrompt = systemPrompt + "\n\nYou can see the user's screen. Describe what you see and help them with their request.";
+  switch (config.provider) {
+    case "openrouter":
+      return chatWithVisionOpenRouter(messages, screenshotBase64, visionPrompt);
+    case "ollama":
+      return chatWithVisionOllama(messages, screenshotBase64, visionPrompt);
+    case "anthropic":
+      return chatWithVisionAnthropic(messages, screenshotBase64, visionPrompt);
+    case "openai":
+      return chatWithVisionOpenAI(messages, screenshotBase64, visionPrompt);
+    default:
+      throw new Error(`Vision not supported for provider: ${config.provider}`);
+  }
+}
+async function chatWithVisionOpenRouter(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("openrouter");
+  if (!apiKey) throw new Error("OpenRouter API key not configured");
+  const config = getConfig();
+  let model = config.model;
+  if (!model.includes("gpt-5") && !model.includes("claude") && !model.includes("gemini")) {
+    model = "openai/gpt-5-nano";
+  }
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "text", text: m.content },
+          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
+        ]
+      };
+    }
+    return m;
+  });
+  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": config.openrouter.siteUrl,
+      "X-Title": config.openrouter.appName
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenRouter vision error: ${response.status} - ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.choices?.[0]?.message?.content || "", model };
+}
+async function chatWithVisionOllama(messages, screenshot, systemPrompt) {
+  const config = getConfig();
+  const visionModels = ["llava", "llama3.2-vision", "bakllava"];
+  const model = visionModels.find((m) => config.model.includes(m)) || "llava";
+  const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+  const response = await fetch(`${config.ollamaHost}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      prompt: `${systemPrompt}
+
+User: ${lastUserMsg?.content || "What do you see?"}`,
+      images: [screenshot],
+      stream: false
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Ollama vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.response || "", model };
+}
+async function chatWithVisionAnthropic(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("anthropic");
+  if (!apiKey) throw new Error("Anthropic API key not configured");
+  const chatMessages = messages.filter((m) => m.role !== "system");
+  const lastUserIdx = chatMessages.length - 1;
+  const visionMessages = chatMessages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "image", source: { type: "base64", media_type: "image/png", data: screenshot } },
+          { type: "text", text: m.content }
+        ]
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+  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: 2048,
+      system: systemPrompt,
+      messages: visionMessages
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.content?.[0]?.text || "", model: "claude-3-5-sonnet-20241022" };
+}
+async function chatWithVisionOpenAI(messages, screenshot, systemPrompt) {
+  const apiKey = getApiKey("openai");
+  if (!apiKey) throw new Error("OpenAI API key not configured");
+  const lastUserIdx = messages.length - 1;
+  const visionMessages = messages.map((m, i) => {
+    if (i === lastUserIdx && m.role === "user") {
+      return {
+        role: "user",
+        content: [
+          { type: "text", text: m.content },
+          { type: "image_url", image_url: { url: `data:image/png;base64,${screenshot}` } }
+        ]
+      };
+    }
+    return m;
+  });
+  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-4o",
+      messages: [{ role: "system", content: systemPrompt }, ...visionMessages],
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI vision error: ${error}`);
+  }
+  const data = await response.json();
+  return { content: data.choices?.[0]?.message?.content || "", model: "gpt-4o" };
+}
+
+export {
+  chat,
+  chatWithVision
+};

package/dist/chunk-MOKGR7WE.js

@@ -0,0 +1,344 @@
+import {
+  clickMouse,
+  keyCombo,
+  pressKey,
+  runCommand,
+  typeText
+} from "./chunk-TFHK5CYF.js";
+import {
+  captureScreenshot,
+  describeScreen
+} from "./chunk-OIVTPXE4.js";
+
+// src/services/browser.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function openUrl(url) {
+  const fullUrl = url.startsWith("http") ? url : `https://${url}`;
+  try {
+    if (process.platform === "win32") {
+      await runCommand(`start "" "${fullUrl}"`, 5e3);
+    } else if (process.platform === "darwin") {
+      await runCommand(`open "${fullUrl}"`, 5e3);
+    } else {
+      await runCommand(`xdg-open "${fullUrl}"`, 5e3);
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to open URL"
+    };
+  }
+}
+async function navigateTo(url) {
+  await openUrl(url);
+}
+async function searchGoogle(query) {
+  const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+  return openUrl(searchUrl);
+}
+async function webSearch(query, engine = "google") {
+  const urls = {
+    google: `https://www.google.com/search?q=${encodeURIComponent(query)}`,
+    bing: `https://www.bing.com/search?q=${encodeURIComponent(query)}`,
+    duckduckgo: `https://duckduckgo.com/?q=${encodeURIComponent(query)}`
+  };
+  await openUrl(urls[engine]);
+  await sleep(3e3);
+  const vision = await describeScreen();
+  return `\u{1F50D} Search results for "${query}":
+
+${vision.description}`;
+}
+async function askAI(site, question) {
+  const urls = {
+    perplexity: "https://www.perplexity.ai",
+    chatgpt: "https://chat.openai.com",
+    claude: "https://claude.ai",
+    copilot: "https://copilot.microsoft.com",
+    google: "https://www.google.com"
+  };
+  await openUrl(urls[site]);
+  await sleep(4e3);
+  await typeText(question);
+  await sleep(500);
+  await pressKey("Return");
+  await sleep(site === "google" ? 3e3 : 1e4);
+  const vision = await describeScreen();
+  return {
+    response: vision.description,
+    screenshot: vision.screenshot
+  };
+}
+async function openGmailCompose(to, subject, body) {
+  let url = "https://mail.google.com/mail/u/0/?fs=1&tf=cm";
+  if (to) url += `&to=${encodeURIComponent(to)}`;
+  if (subject) url += `&su=${encodeURIComponent(subject)}`;
+  if (body) url += `&body=${encodeURIComponent(body)}`;
+  const result = await openUrl(url);
+  return result.success;
+}
+async function sendGmail(email) {
+  try {
+    await openGmailCompose(email.to, email.subject, email.body);
+    await sleep(5e3);
+    await keyCombo(["control", "Return"]);
+    await sleep(2e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function openOutlookCompose(to, subject, body) {
+  let url = "https://outlook.office.com/mail/deeplink/compose?";
+  if (to) url += `to=${encodeURIComponent(to)}&`;
+  if (subject) url += `subject=${encodeURIComponent(subject)}&`;
+  if (body) url += `body=${encodeURIComponent(body)}&`;
+  const result = await openUrl(url);
+  return result.success;
+}
+async function sendOutlook(email) {
+  try {
+    await openOutlookCompose(email.to, email.subject, email.body);
+    await sleep(5e3);
+    await keyCombo(["control", "Return"]);
+    await sleep(2e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function openGoogleSheet() {
+  const result = await openUrl("https://docs.google.com/spreadsheets/create");
+  return result.success;
+}
+async function openGoogleDoc() {
+  const result = await openUrl("https://docs.google.com/document/create");
+  return result.success;
+}
+async function typeInBrowser(text) {
+  await typeText(text);
+}
+async function pressKey2(key) {
+  await pressKey(key);
+}
+async function click(button = "left") {
+  await clickMouse(button);
+}
+async function scroll(direction, amount = 3) {
+  const key = direction === "down" ? "pagedown" : "pageup";
+  for (let i = 0; i < amount; i++) {
+    await pressKey(key);
+    await sleep(200);
+  }
+}
+async function takeScreenshot() {
+  return await captureScreenshot();
+}
+async function getPageText() {
+  const vision = await describeScreen();
+  return vision.description;
+}
+async function research(topic, maxSources = 3) {
+  await searchGoogle(topic);
+  await sleep(3e3);
+  const searchResults = await describeScreen();
+  return {
+    query: topic,
+    sources: [{
+      title: `Google search: ${topic}`,
+      url: `https://www.google.com/search?q=${encodeURIComponent(topic)}`,
+      content: searchResults.description
+    }],
+    summary: searchResults.description
+  };
+}
+async function closeTab() {
+  await keyCombo(["control", "w"]);
+}
+async function newTab() {
+  await keyCombo(["control", "t"]);
+}
+async function nextTab() {
+  await keyCombo(["control", "Tab"]);
+}
+async function goBack() {
+  await keyCombo(["alt", "Left"]);
+}
+async function goForward() {
+  await keyCombo(["alt", "Right"]);
+}
+async function refresh() {
+  await pressKey("F5");
+}
+async function focusAddressBar() {
+  await keyCombo(["control", "l"]);
+}
+async function typeUrl(url) {
+  await focusAddressBar();
+  await sleep(300);
+  await typeText(url);
+  await sleep(200);
+  await pressKey("Return");
+}
+async function initBrowser() {
+  return null;
+}
+async function getPage() {
+  return null;
+}
+async function closeBrowser() {
+  await keyCombo(["alt", "F4"]);
+}
+async function elementExists(selector) {
+  return true;
+}
+async function clickElement(selector) {
+  await click();
+  return true;
+}
+async function typeInElement(selector, text) {
+  await typeInBrowser(text);
+  return true;
+}
+async function typeSlowly(selector, text) {
+  for (const char of text) {
+    await typeText(char);
+    await sleep(50);
+  }
+  return true;
+}
+async function waitForText(text) {
+  await sleep(3e3);
+  return true;
+}
+async function getTextContent(selector) {
+  const vision = await describeScreen();
+  return vision.description;
+}
+async function waitForNavigation() {
+  await sleep(3e3);
+}
+async function getFullAIResponse(site, maxScrolls = 5) {
+  const responses = [];
+  for (let i = 0; i < maxScrolls; i++) {
+    const vision = await describeScreen();
+    responses.push(vision.description);
+    await scroll("down", 1);
+    await sleep(1e3);
+  }
+  return responses;
+}
+async function googleSheetsType(cells) {
+  try {
+    for (const { cell, value } of cells) {
+      await keyCombo(["control", "g"]);
+      await sleep(500);
+      await typeText(cell);
+      await pressKey("Return");
+      await sleep(300);
+      await typeText(value);
+      await pressKey("Return");
+      await sleep(200);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function googleDocsType(text) {
+  try {
+    await sleep(1e3);
+    await typeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var browser_default = {
+  openUrl,
+  navigateTo,
+  searchGoogle,
+  webSearch,
+  askAI,
+  openGmailCompose,
+  sendGmail,
+  openOutlookCompose,
+  sendOutlook,
+  openGoogleSheet,
+  openGoogleDoc,
+  typeInBrowser,
+  pressKey: pressKey2,
+  click,
+  scroll,
+  takeScreenshot,
+  getPageText,
+  research,
+  closeTab,
+  newTab,
+  nextTab,
+  goBack,
+  goForward,
+  refresh,
+  focusAddressBar,
+  typeUrl,
+  // Legacy compatibility
+  initBrowser,
+  getPage,
+  closeBrowser,
+  elementExists,
+  clickElement,
+  typeInElement,
+  typeSlowly,
+  waitForText,
+  getTextContent,
+  waitForNavigation,
+  getFullAIResponse,
+  googleSheetsType,
+  googleDocsType
+};
+
+export {
+  openUrl,
+  navigateTo,
+  searchGoogle,
+  webSearch,
+  askAI,
+  openGmailCompose,
+  sendGmail,
+  openOutlookCompose,
+  sendOutlook,
+  openGoogleSheet,
+  openGoogleDoc,
+  typeInBrowser,
+  pressKey2 as pressKey,
+  click,
+  scroll,
+  takeScreenshot,
+  getPageText,
+  research,
+  closeTab,
+  newTab,
+  nextTab,
+  goBack,
+  goForward,
+  refresh,
+  focusAddressBar,
+  typeUrl,
+  initBrowser,
+  getPage,
+  closeBrowser,
+  elementExists,
+  clickElement,
+  typeInElement,
+  typeSlowly,
+  waitForText,
+  getTextContent,
+  waitForNavigation,
+  getFullAIResponse,
+  googleSheetsType,
+  googleDocsType,
+  browser_default
+};