apteva 0.1.5 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apteva",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "description": "Run AI agents locally. Multi-provider support for Claude, GPT, Gemini, Llama, and more.",
   "type": "module",
   "main": "./dist/index.js",

package/src/binary.ts

@@ -3,6 +3,18 @@ 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 MAX_RETRIES = 3;
+const RETRY_DELAY = 2000; // 2 seconds
+
+// ANSI colors for console output
+const c = {
+  reset: "\x1b[0m",
+  orange: "\x1b[38;5;208m",
+  gray: "\x1b[38;5;245m",
+  green: "\x1b[38;5;82m",
+  red: "\x1b[38;5;196m",
+};
 
 // Determine platform and architecture
 function getPlatformInfo(): { platform: string; arch: string; ext: string } {
@@ -40,8 +52,26 @@ export function binaryExists(binDir: string): boolean {
   return existsSync(getBinaryPath(binDir));
 }
 
+// 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> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (err) {
+    clearTimeout(timeoutId);
+    throw err;
+  }
+}
+
 // Download binary if missing
-export async function ensureBinary(binDir: string): Promise<{ success: boolean; path: string; error?: string }> {
+export async function ensureBinary(binDir: string, silent = false): Promise<{ success: boolean; path: string; error?: string; downloaded?: boolean }> {
   const binaryPath = getBinaryPath(binDir);
 
   // Ensure bin directory exists
@@ -51,46 +81,81 @@ export async function ensureBinary(binDir: string): Promise<{ success: boolean;
 
   // Check if already exists
   if (existsSync(binaryPath)) {
-    return { success: true, path: binaryPath };
+    return { success: true, path: binaryPath, downloaded: false };
   }
 
   const url = getDownloadUrl();
+  const filename = getBinaryFilename();
 
-  try {
-    const response = await fetch(url);
-
-    if (!response.ok) {
-      // For now, since binaries don't exist yet, create a placeholder message
-      if (response.status === 404) {
-        return {
-          success: false,
-          path: binaryPath,
-          error: `Agent binary not available yet. Binary URL: ${url}\n\nThe agent binary will be available in a future release. For now, you can:\n1. Build your own agent binary\n2. Set AGENT_BINARY_PATH environment variable to point to your binary`,
-        };
-      }
-      return {
-        success: false,
-        path: binaryPath,
-        error: `Failed to download binary: HTTP ${response.status}`,
-      };
-    }
+  // Show downloading message (server.ts already printed "Binary    ")
+  if (!silent) {
+    process.stdout.write(`${c.orange}downloading...${c.reset}`);
+  }
+
+  let lastError: string = "";
 
-    const arrayBuffer = await response.arrayBuffer();
-    await Bun.write(binaryPath, arrayBuffer);
+  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}   `);
+      }
 
-    // Make executable on Unix systems
-    if (process.platform !== "win32") {
-      chmodSync(binaryPath, 0o755);
+      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 };
-  } catch (err) {
-    return {
-      success: false,
-      path: binaryPath,
-      error: `Failed to download binary: ${err}`,
-    };
+  // All retries failed
+  if (!silent) {
+    console.log(`\r${c.red}failed${c.reset} ${c.gray}(${lastError})${c.reset}   `);
   }
+
+  return {
+    success: false,
+    path: binaryPath,
+    error: `Failed after ${MAX_RETRIES} attempts: ${lastError}`,
+  };
 }
 
 // Get binary status info

package/src/routes/static.ts

@@ -1,5 +1,5 @@
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 
 // Find dist directory - handle both development and npx contexts
 function findDistDir(): string {
@@ -10,8 +10,15 @@ function findDistDir(): string {
   ];
 
   for (const dir of candidates) {
-    if (existsSync(join(dir, "index.html"))) {
-      return dir;
+    try {
+      if (existsSync(dir) && statSync(dir).isDirectory()) {
+        const indexPath = join(dir, "index.html");
+        if (existsSync(indexPath)) {
+          return dir;
+        }
+      }
+    } catch {
+      continue;
     }
   }
 
@@ -20,33 +27,71 @@ function findDistDir(): string {
 
 const DIST_DIR = findDistDir();
 
-export async function serveStatic(req: Request, path: string): Promise<Response> {
-  // Default to index.html for root and SPA routes
-  let filePath = path === "/" ? "/index.html" : path;
+// MIME types for common file extensions
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+};
+
+function getMimeType(path: string): string {
+  const ext = path.substring(path.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
 
+export async function serveStatic(req: Request, path: string): Promise<Response> {
   try {
-    // Try to serve the file
+    // Default to index.html for root
+    let filePath = path === "/" ? "/index.html" : path;
+
+    // Prevent directory traversal attacks
+    if (filePath.includes("..")) {
+      return new Response("Forbidden", { status: 403 });
+    }
+
     const fullPath = join(DIST_DIR, filePath);
-    const file = Bun.file(fullPath);
 
-    if (await file.exists()) {
-      return new Response(file);
+    // Check if file exists using sync API (more reliable)
+    if (existsSync(fullPath)) {
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isFile()) {
+          const file = Bun.file(fullPath);
+          const mimeType = getMimeType(filePath);
+          return new Response(file, {
+            headers: { "Content-Type": mimeType },
+          });
+        }
+      } catch {
+        // Fall through to SPA handling
+      }
     }
 
     // For SPA: if file doesn't exist and it's not a static asset, serve index.html
     if (!path.includes(".")) {
-      const indexFile = Bun.file(join(DIST_DIR, "index.html"));
-      if (await indexFile.exists()) {
-        return new Response(indexFile);
+      const indexPath = join(DIST_DIR, "index.html");
+      if (existsSync(indexPath)) {
+        const indexFile = Bun.file(indexPath);
+        return new Response(indexFile, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
       }
     }
-  } catch (e) {
-    // Fall through to fallback
-  }
 
-  // If dist doesn't exist, serve a development message
-  return new Response(
-    `<!DOCTYPE html>
+    // If dist doesn't exist, serve a development message
+    return new Response(
+      `<!DOCTYPE html>
 <html>
 <head>
   <title>Apteva</title>
@@ -64,6 +109,13 @@ export async function serveStatic(req: Request, path: string): Promise<Response>
   </div>
 </body>
 </html>`,
-    { headers: { "Content-Type": "text/html" } }
-  );
+      {
+        status: 200,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      }
+    );
+  } catch (error) {
+    console.error("Static file error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
 }

package/src/server.ts

@@ -73,13 +73,13 @@ console.log(`
   ${c.gray}Run AI agents locally${c.reset}
 `);
 
-// Check binary
-process.stdout.write(`  ${c.darkGray}Binary${c.reset}    `);
+// Check binary - ensureBinary handles progress output when downloading
+process.stdout.write(`  ${c.darkGray}Agent${c.reset}     `);
 const binaryResult = await ensureBinary(BIN_DIR);
-if (!binaryResult.success) {
-  console.log(`${c.orange}not available${c.reset}`);
-} else {
-  console.log(`${c.gray}ready${c.reset}`);
+// 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}binary ready${c.reset}`);
 }
 
 // Check database
@@ -93,6 +93,8 @@ console.log(`${c.gray}${configuredProviders.length} configured${c.reset}`);
 
 const server = Bun.serve({
   port: PORT,
+  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);