apteva 0.1.7 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apteva",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "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,15 +171,19 @@ 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 };
+    return {
+      success: true,
+      path: binaryPath,
+      downloaded: false,
+      source: "cached"
+    };
   }
 
+  // Need to download - show message
   const url = getDownloadUrl();
-  const filename = getBinaryFilename();
 
-  // Show downloading message (server.ts already printed "Binary    ")
   if (!silent) {
     process.stdout.write(`${c.orange}downloading...${c.reset}`);
   }
@@ -97,47 +193,41 @@ export async function ensureBinary(binDir: string, silent = false): Promise<{ su
   for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
     try {
       if (!silent && attempt > 1) {
-        // Clear line and show retry status
-        process.stdout.write(`\r  Binary    ${c.orange}retry ${attempt}/${MAX_RETRIES}...${c.reset}   `);
+        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);
-        }
+      const arrayBuffer = await downloadWithTimeout(url);
+      await Bun.write(binaryPath, arrayBuffer);
 
-        // Show success
-        if (!silent) {
-          const sizeMB = (arrayBuffer.byteLength / 1024 / 1024).toFixed(1);
-          console.log(`\r${c.green}ready${c.reset} ${c.gray}(${sizeMB}MB downloaded)${c.reset}   `);
-        }
+      // Make executable on Unix systems
+      if (process.platform !== "win32") {
+        chmodSync(binaryPath, 0o755);
+      }
 
-        return { success: true, path: binaryPath, downloaded: true };
+      // Show success
+      if (!silent) {
+        const sizeMB = (arrayBuffer.byteLength / 1024 / 1024).toFixed(1);
+        console.log(`\r${c.green}ready${c.reset} ${c.gray}(${sizeMB}MB downloaded)${c.reset}   `);
       }
+
+      return {
+        success: true,
+        path: binaryPath,
+        downloaded: true,
+        source: "download"
+      };
     } catch (err: any) {
+      if (err.message?.startsWith("HTTP 404")) {
+        if (!silent) {
+          console.log(`\r${c.red}not found${c.reset}           `);
+        }
+        return {
+          success: false,
+          path: binaryPath,
+          error: `Binary not found at ${url}`,
+        };
+      }
+
       lastError = err.name === "AbortError" ? "timeout" : String(err.message || err);
       if (attempt < MAX_RETRIES) {
         await sleep(RETRY_DELAY);
@@ -166,16 +256,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/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 };
@@ -74,12 +84,12 @@ console.log(`
 `);
 
 // Check binary - ensureBinary handles progress output when downloading
-process.stdout.write(`  ${c.darkGray}Binary${c.reset}    `);
+process.stdout.write(`  ${c.darkGray}Agent${c.reset}     `);
 const binaryResult = await ensureBinary(BIN_DIR);
 // ensureBinary prints its own status when downloading/failing
 // We only need to print "ready" if binary already existed
 if (binaryResult.success && !binaryResult.downloaded) {
-  console.log(`${c.gray}ready${c.reset}`);
+  console.log(`${c.gray}binary ready${c.reset}`);
 }
 
 // Check database
@@ -93,7 +103,8 @@ console.log(`${c.gray}${configuredProviders.length} configured${c.reset}`);
 
 const server = Bun.serve({
   port: PORT,
-  development: false, // Suppress "Started development server" message
+  hostname: "0.0.0.0", // Listen on all interfaces
+  development: false, // Suppress "Started server" message
 
   async fetch(req: Request): Promise<Response> {
     const url = new URL(req.url);
@@ -132,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