apteva 0.1.8 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apteva",
-  "version": "0.1.8",
+  "version": "0.2.1",
   "description": "Run AI agents locally. Multi-provider support for Claude, GPT, Gemini, Llama, and more.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,5 +63,12 @@
     "@apteva/apteva-kit": "^0.1.102",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
+  },
+  "optionalDependencies": {
+    "@apteva/agent-darwin-arm64": "^0.2.0",
+    "@apteva/agent-darwin-x64": "^0.2.0",
+    "@apteva/agent-linux-x64": "^0.2.0",
+    "@apteva/agent-linux-arm64": "^0.2.0",
+    "@apteva/agent-win32-x64": "^0.2.0"
   }
 }

package/src/binary.ts

@@ -3,9 +3,10 @@ import { existsSync, mkdirSync, chmodSync } from "fs";
 
 // Binary configuration
 const BINARY_BASE_URL = "https://github.com/apteva/agent/releases/latest/download";
-const DOWNLOAD_TIMEOUT = 60000; // 60 seconds
+const CONNECT_TIMEOUT = 15000; // 15 seconds for initial connection
+const DOWNLOAD_TIMEOUT = 120000; // 120 seconds for full download
 const MAX_RETRIES = 3;
-const RETRY_DELAY = 2000; // 2 seconds
+const RETRY_DELAY = 1000; // 1 second between retries
 
 // ANSI colors for console output
 const c = {
@@ -16,12 +17,56 @@ const c = {
   red: "\x1b[38;5;196m",
 };
 
-// Determine platform and architecture
+// Map Node.js platform/arch to npm package names
+function getNpmPackageName(): string {
+  const platform = process.platform; // darwin, linux, win32
+  const arch = process.arch; // x64, arm64
+
+  // Map to our package naming convention
+  const archMap: Record<string, string> = {
+    x64: "x64",
+    arm64: "arm64",
+  };
+
+  const mappedArch = archMap[arch] || arch;
+  return `@apteva/agent-${platform}-${mappedArch}`;
+}
+
+// Try to find binary from installed npm package
+function findNpmBinary(): string | null {
+  const packageName = getNpmPackageName();
+
+  try {
+    // Try to require the package - it exports the binary path
+    const binaryPath = require(packageName);
+    if (existsSync(binaryPath)) {
+      return binaryPath;
+    }
+  } catch {
+    // Package not installed, fall through
+  }
+
+  // Also try direct path resolution in node_modules
+  const possiblePaths = [
+    join(import.meta.dir, "../../node_modules", packageName, process.platform === "win32" ? "agent.exe" : "agent"),
+    join(process.cwd(), "node_modules", packageName, process.platform === "win32" ? "agent.exe" : "agent"),
+  ];
+
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+
+  return null;
+}
+
+// Determine platform and architecture for download fallback
 function getPlatformInfo(): { platform: string; arch: string; ext: string } {
   const platform = process.platform === "win32" ? "windows" : process.platform;
   let arch = process.arch;
 
-  // Normalize architecture names
+  // Normalize architecture names for GitHub releases
   if (arch === "x64") arch = "amd64";
   if (arch === "arm64") arch = "arm64";
 
@@ -30,13 +75,13 @@ function getPlatformInfo(): { platform: string; arch: string; ext: string } {
   return { platform, arch, ext };
 }
 
-// Get binary filename for current platform
+// Get binary filename for current platform (for download)
 export function getBinaryFilename(): string {
   const { platform, arch, ext } = getPlatformInfo();
   return `agent-${platform}-${arch}${ext}`;
 }
 
-// Get full binary path
+// Get full binary path in bin directory
 export function getBinaryPath(binDir: string): string {
   return join(binDir, getBinaryFilename());
 }
@@ -47,31 +92,78 @@ function getDownloadUrl(): string {
   return `${BINARY_BASE_URL}/${filename}`;
 }
 
-// Check if binary exists
+// Check if binary exists (either from npm or downloaded)
 export function binaryExists(binDir: string): boolean {
+  // First check npm package
+  const npmBinary = findNpmBinary();
+  if (npmBinary) return true;
+
+  // Then check downloaded binary
   return existsSync(getBinaryPath(binDir));
 }
 
+// Get the actual binary path (npm or downloaded)
+export function getActualBinaryPath(binDir: string): string | null {
+  // First check npm package
+  const npmBinary = findNpmBinary();
+  if (npmBinary) return npmBinary;
+
+  // Then check downloaded binary
+  const downloadedPath = getBinaryPath(binDir);
+  if (existsSync(downloadedPath)) return downloadedPath;
+
+  return null;
+}
+
 // Helper to delay
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-// Download with timeout
-async function fetchWithTimeout(url: string, timeout: number): Promise<Response> {
+// Download file with timeout for both connection and body
+async function downloadWithTimeout(url: string): Promise<ArrayBuffer> {
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  // Timeout for connection
+  let timeoutId = setTimeout(() => controller.abort(), CONNECT_TIMEOUT);
+
+  const response = await fetch(url, { signal: controller.signal });
+  clearTimeout(timeoutId);
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+
+  // Timeout for body download
+  timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT);
 
   try {
-    const response = await fetch(url, { signal: controller.signal });
+    const arrayBuffer = await response.arrayBuffer();
     clearTimeout(timeoutId);
-    return response;
+    return arrayBuffer;
   } catch (err) {
     clearTimeout(timeoutId);
     throw err;
   }
 }
 
-// Download binary if missing
-export async function ensureBinary(binDir: string, silent = false): Promise<{ success: boolean; path: string; error?: string; downloaded?: boolean }> {
+// Ensure binary exists - check npm first, then download
+export async function ensureBinary(binDir: string, silent = false): Promise<{
+  success: boolean;
+  path: string;
+  error?: string;
+  downloaded?: boolean;
+  source?: "npm" | "download" | "cached";
+}> {
+  // First, check if binary is available from npm package
+  const npmBinary = findNpmBinary();
+  if (npmBinary) {
+    return {
+      success: true,
+      path: npmBinary,
+      downloaded: false,
+      source: "npm"
+    };
+  }
+
   const binaryPath = getBinaryPath(binDir);
 
   // Ensure bin directory exists
@@ -79,82 +171,26 @@ export async function ensureBinary(binDir: string, silent = false): Promise<{ su
     mkdirSync(binDir, { recursive: true });
   }
 
-  // Check if already exists
+  // Check if already downloaded
   if (existsSync(binaryPath)) {
-    return { success: true, path: binaryPath, downloaded: false };
-  }
-
-  const url = getDownloadUrl();
-  const filename = getBinaryFilename();
-
-  // Show downloading message (server.ts already printed "Binary    ")
-  if (!silent) {
-    process.stdout.write(`${c.orange}downloading...${c.reset}`);
-  }
-
-  let lastError: string = "";
-
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      if (!silent && attempt > 1) {
-        // Clear line and show retry status
-        process.stdout.write(`\r  Agent     ${c.orange}retry ${attempt}/${MAX_RETRIES}...${c.reset}   `);
-      }
-
-      const response = await fetchWithTimeout(url, DOWNLOAD_TIMEOUT);
-
-      if (!response.ok) {
-        if (response.status === 404) {
-          if (!silent) {
-            console.log(`\r${c.red}not found${c.reset}           `);
-          }
-          return {
-            success: false,
-            path: binaryPath,
-            error: `Binary not found at ${url}`,
-          };
-        }
-        lastError = `HTTP ${response.status}`;
-        if (attempt < MAX_RETRIES) {
-          await sleep(RETRY_DELAY);
-          continue;
-        }
-      } else {
-        // Download the binary
-        const arrayBuffer = await response.arrayBuffer();
-        await Bun.write(binaryPath, arrayBuffer);
-
-        // Make executable on Unix systems
-        if (process.platform !== "win32") {
-          chmodSync(binaryPath, 0o755);
-        }
-
-        // Show success
-        if (!silent) {
-          const sizeMB = (arrayBuffer.byteLength / 1024 / 1024).toFixed(1);
-          console.log(`\r${c.green}binary ready${c.reset} ${c.gray}(${sizeMB}MB downloaded)${c.reset}   `);
-        }
-
-        return { success: true, path: binaryPath, downloaded: true };
-      }
-    } catch (err: any) {
-      lastError = err.name === "AbortError" ? "timeout" : String(err.message || err);
-      if (attempt < MAX_RETRIES) {
-        await sleep(RETRY_DELAY);
-        continue;
-      }
-    }
+    return {
+      success: true,
+      path: binaryPath,
+      downloaded: false,
+      source: "cached"
+    };
   }
 
-  // All retries failed
+  // No npm package and no cached binary - show error
   if (!silent) {
-    console.log(`\r${c.red}failed${c.reset} ${c.gray}(${lastError})${c.reset}   `);
+    console.log(`${c.red}not found${c.reset}`);
+    console.log(`\n  Install the agent binary: npm install @apteva/agent-linux-x64`);
   }
 
   return {
     success: false,
     path: binaryPath,
-    error: `Failed after ${MAX_RETRIES} attempts: ${lastError}`,
+    error: "Binary not found. Install via: npm install @apteva/agent-<platform>",
   };
 }
 
@@ -166,16 +202,45 @@ export function getBinaryStatus(binDir: string): {
   downloadUrl: string;
   platform: string;
   arch: string;
+  source?: "npm" | "download" | "none";
 } {
   const { platform, arch } = getPlatformInfo();
-  const path = getBinaryPath(binDir);
+
+  // Check npm first
+  const npmBinary = findNpmBinary();
+  if (npmBinary) {
+    return {
+      exists: true,
+      path: npmBinary,
+      filename: getBinaryFilename(),
+      downloadUrl: getDownloadUrl(),
+      platform,
+      arch,
+      source: "npm",
+    };
+  }
+
+  // Check downloaded
+  const downloadedPath = getBinaryPath(binDir);
+  if (existsSync(downloadedPath)) {
+    return {
+      exists: true,
+      path: downloadedPath,
+      filename: getBinaryFilename(),
+      downloadUrl: getDownloadUrl(),
+      platform,
+      arch,
+      source: "download",
+    };
+  }
 
   return {
-    exists: existsSync(path),
-    path,
+    exists: false,
+    path: downloadedPath,
     filename: getBinaryFilename(),
     downloadUrl: getDownloadUrl(),
     platform,
     arch,
+    source: "none",
   };
 }

package/src/providers.ts

@@ -6,91 +6,61 @@ export const PROVIDERS = {
   anthropic: {
     id: "anthropic",
     name: "Anthropic",
-    displayName: "Anthropic (Claude)",
+    displayName: "Anthropic",
     envVar: "ANTHROPIC_API_KEY",
     docsUrl: "https://console.anthropic.com/settings/keys",
     testEndpoint: "https://api.anthropic.com/v1/messages",
     models: [
-      { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4", recommended: true },
-      { value: "claude-opus-4-20250514", label: "Claude Opus 4" },
-      { value: "claude-4-5-sonnet", label: "Claude 4.5 Sonnet" },
-      { value: "claude-4-5-haiku", label: "Claude 4.5 Haiku (Fast)" },
+      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5", recommended: true },
+      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)" },
     ],
   },
   openai: {
     id: "openai",
     name: "OpenAI",
-    displayName: "OpenAI (GPT)",
+    displayName: "OpenAI",
     envVar: "OPENAI_API_KEY",
     docsUrl: "https://platform.openai.com/api-keys",
     testEndpoint: "https://api.openai.com/v1/models",
     models: [
       { value: "gpt-4o", label: "GPT-4o", recommended: true },
       { value: "gpt-4o-mini", label: "GPT-4o Mini (Fast)" },
-      { value: "gpt-4-turbo", label: "GPT-4 Turbo" },
     ],
   },
   groq: {
     id: "groq",
     name: "Groq",
-    displayName: "Groq (Ultra-fast)",
+    displayName: "Groq",
     envVar: "GROQ_API_KEY",
     docsUrl: "https://console.groq.com/keys",
     testEndpoint: "https://api.groq.com/openai/v1/models",
     models: [
       { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B", recommended: true },
-      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Instant)" },
-      { value: "mixtral-8x7b-32768", label: "Mixtral 8x7B" },
+      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Fast)" },
     ],
   },
   gemini: {
     id: "gemini",
     name: "Google",
-    displayName: "Google (Gemini)",
+    displayName: "Google Gemini",
     envVar: "GEMINI_API_KEY",
     docsUrl: "https://aistudio.google.com/app/apikey",
     testEndpoint: "https://generativelanguage.googleapis.com/v1/models",
     models: [
-      { value: "gemini-2.0-flash", label: "Gemini 2.0 Flash", recommended: true },
-      { value: "gemini-1.5-pro", label: "Gemini 1.5 Pro" },
-      { value: "gemini-1.5-flash", label: "Gemini 1.5 Flash" },
-    ],
-  },
-  fireworks: {
-    id: "fireworks",
-    name: "Fireworks",
-    displayName: "Fireworks AI",
-    envVar: "FIREWORKS_API_KEY",
-    docsUrl: "https://fireworks.ai/api-keys",
-    testEndpoint: "https://api.fireworks.ai/inference/v1/models",
-    models: [
-      { value: "accounts/fireworks/models/llama-v3p3-70b-instruct", label: "Llama 3.3 70B", recommended: true },
-      { value: "accounts/fireworks/models/deepseek-v3", label: "DeepSeek V3" },
-      { value: "accounts/fireworks/models/qwen2p5-72b-instruct", label: "Qwen 2.5 72B" },
+      { value: "gemini-3-pro-preview", label: "Gemini 3 Pro Preview (Latest)", recommended: true },
+      { value: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview (Fast)" },
     ],
   },
   xai: {
     id: "xai",
     name: "xAI",
-    displayName: "xAI (Grok)",
+    displayName: "xAI Grok",
     envVar: "XAI_API_KEY",
     docsUrl: "https://console.x.ai/",
     testEndpoint: "https://api.x.ai/v1/models",
     models: [
-      { value: "grok-2-latest", label: "Grok 2", recommended: true },
-      { value: "grok-beta", label: "Grok Beta" },
-    ],
-  },
-  moonshot: {
-    id: "moonshot",
-    name: "Moonshot",
-    displayName: "Moonshot AI (Kimi)",
-    envVar: "MOONSHOT_API_KEY",
-    docsUrl: "https://platform.moonshot.cn/console/api-keys",
-    testEndpoint: "https://api.moonshot.cn/v1/models",
-    models: [
-      { value: "moonshot-v1-128k", label: "Moonshot V1 128K", recommended: true },
-      { value: "moonshot-v1-32k", label: "Moonshot V1 32K" },
+      { value: "grok-2", label: "Grok 2", recommended: true },
+      { value: "grok-2-mini", label: "Grok 2 Mini (Fast)" },
     ],
   },
   together: {
@@ -101,20 +71,32 @@ export const PROVIDERS = {
     docsUrl: "https://api.together.xyz/settings/api-keys",
     testEndpoint: "https://api.together.xyz/v1/models",
     models: [
-      { value: "meta-llama/Llama-3.3-70B-Instruct-Turbo", label: "Llama 3.3 70B", recommended: true },
-      { value: "deepseek-ai/DeepSeek-R1", label: "DeepSeek R1" },
-      { value: "deepseek-ai/DeepSeek-V3", label: "DeepSeek V3" },
+      { value: "moonshotai/Kimi-K2.5", label: "Kimi K2.5", recommended: true },
+      { value: "moonshotai/Kimi-K2-Thinking", label: "Kimi K2 Thinking (Reasoning)" },
     ],
   },
-  venice: {
-    id: "venice",
-    name: "Venice",
-    displayName: "Venice AI",
-    envVar: "VENICE_API_KEY",
-    docsUrl: "https://venice.ai/settings/api",
-    testEndpoint: "https://api.venice.ai/api/v1/models",
+  fireworks: {
+    id: "fireworks",
+    name: "Fireworks",
+    displayName: "Fireworks AI",
+    envVar: "FIREWORKS_API_KEY",
+    docsUrl: "https://fireworks.ai/api-keys",
+    testEndpoint: "https://api.fireworks.ai/inference/v1/models",
+    models: [
+      { value: "accounts/fireworks/models/kimi-k2p5", label: "Kimi K2.5", recommended: true },
+      { value: "accounts/fireworks/models/kimi-k2-thinking", label: "Kimi K2 Thinking (Reasoning)" },
+    ],
+  },
+  moonshot: {
+    id: "moonshot",
+    name: "Moonshot",
+    displayName: "Moonshot AI",
+    envVar: "MOONSHOT_API_KEY",
+    docsUrl: "https://platform.moonshot.cn/console/api-keys",
+    testEndpoint: "https://api.moonshot.cn/v1/models",
     models: [
-      { value: "llama-3.3-70b", label: "Llama 3.3 70B", recommended: true },
+      { value: "moonshot-v1-128k", label: "Kimi 128K", recommended: true },
+      { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)" },
     ],
   },
 } as const;

package/src/routes/api.ts

@@ -172,8 +172,8 @@ export async function handleApiRequest(req: Request, path: string): Promise<Resp
       const proc = spawn({
         cmd: [BINARY_PATH],
         env,
-        stdout: "inherit",
-        stderr: "inherit",
+        stdout: "ignore",
+        stderr: "ignore",
       });
 
       agentProcesses.set(agent.id, proc);

package/src/server.ts

@@ -3,7 +3,7 @@ import { handleApiRequest } from "./routes/api";
 import { serveStatic } from "./routes/static";
 import { join } from "path";
 import { initDatabase, AgentDB, ProviderKeysDB } from "./db";
-import { ensureBinary, getBinaryPath, getBinaryStatus } from "./binary";
+import { ensureBinary, getBinaryPath, getBinaryStatus, getActualBinaryPath } from "./binary";
 
 const PORT = parseInt(process.env.PORT || "4280");
 const DATA_DIR = process.env.DATA_DIR || join(import.meta.dir, "../data");
@@ -31,8 +31,18 @@ AgentDB.resetAllStatus();
 // In-memory store for running agent processes only
 export const agentProcesses: Map<string, Subprocess> = new Map();
 
-// Binary path - can be overridden via environment variable
-export const BINARY_PATH = process.env.AGENT_BINARY_PATH || getBinaryPath(BIN_DIR);
+// Binary path - can be overridden via environment variable, or found from npm/downloaded
+export function getBinaryPathForAgent(): string {
+  // Environment override takes priority
+  if (process.env.AGENT_BINARY_PATH) {
+    return process.env.AGENT_BINARY_PATH;
+  }
+  // Otherwise use npm package or downloaded binary
+  return getActualBinaryPath(BIN_DIR) || getBinaryPath(BIN_DIR);
+}
+
+// Export for legacy compatibility
+export const BINARY_PATH = getBinaryPathForAgent();
 
 // Export binary status function for API
 export { getBinaryStatus, BIN_DIR };
@@ -133,4 +143,4 @@ console.log(`
             ${c.darkGray}Click link or Cmd/Ctrl+C to copy${c.reset}
 `);
 
-export default server;
+// Note: Don't use "export default server" - it causes Bun to print "Started server" message