apteva 0.4.30 → 0.4.32

package/bin/apteva.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 
-import { spawn } from "child_process";
+import { spawn, execFileSync } from "child_process";
+import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
 
 // Parse command line arguments
 const args = process.argv.slice(2);
@@ -32,8 +34,9 @@ for (let i = 0; i < args.length; i++) {
 }
 
 if (showVersion) {
-  const pkg = await import("../package.json", { assert: { type: "json" } });
-  console.log(`apteva v${pkg.default.version}`);
+  const pkgPath = join(__dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  console.log(`apteva v${pkg.version}`);
   process.exit(0);
 }
 
@@ -82,19 +85,7 @@ DOCUMENTATION:
   process.exit(0);
 }
 
-// Find the server entry point
-const serverPath = join(__dirname, "..", "src", "server.ts");
-const distServerPath = join(__dirname, "..", "dist", "server.js");
-
-let entryPoint;
-if (existsSync(serverPath)) {
-  entryPoint = serverPath;
-} else if (existsSync(distServerPath)) {
-  entryPoint = distServerPath;
-} else {
-  console.error("Error: Could not find server entry point");
-  process.exit(1);
-}
+// ============ Find the server executable ============
 
 // Build environment
 const env = { ...process.env };
@@ -102,46 +93,104 @@ env.PORT = String(port);
 if (dataDir) env.DATA_DIR = dataDir;
 if (configFile) env.CONFIG_FILE = configFile;
 
-// Check if bun is available
-const runtime = process.env.BUN_INSTALL ? "bun" : "node";
+// Strategy 1: Compiled platform binary (works without Bun)
+function findCompiledBinary() {
+  const platform = { darwin: "darwin", linux: "linux", win32: "win32" }[process.platform];
+  const arch = { x64: "x64", arm64: "arm64" }[process.arch];
+  if (!platform || !arch) return null;
+
+  const packageName = `@apteva/apteva-${platform}-${arch}`;
+
+  // Try require.resolve() first (most reliable for npm-installed packages)
+  try {
+    const binaryPath = require(packageName);
+    if (existsSync(binaryPath)) return binaryPath;
+  } catch {
+    // Package not installed
+  }
+
+  // Try direct paths in node_modules
+  const binaryName = process.platform === "win32" ? "apteva.exe" : "apteva";
+  const directPaths = [
+    join(__dirname, "..", "node_modules", packageName, binaryName),
+    join(__dirname, "..", "..", packageName, binaryName),
+  ];
+  for (const p of directPaths) {
+    if (existsSync(p)) return p;
+  }
+
+  // Try postinstall symlink
+  const symlinkPath = join(__dirname, process.platform === "win32" ? "apteva-server.exe" : "apteva-server");
+  if (existsSync(symlinkPath)) return symlinkPath;
+
+  return null;
+}
+
+// Strategy 2: Source mode with Bun
+function findSourceEntry() {
+  const serverPath = join(__dirname, "..", "src", "server.ts");
+  if (existsSync(serverPath)) return serverPath;
+  return null;
+}
+
+function hasBun() {
+  try {
+    execFileSync("bun", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-// Build args - use --silent for bun to suppress "Started development server" message
-const runtimeArgs = runtime === "bun" ? ["--silent", entryPoint] : [entryPoint];
+// Try compiled binary first
+const compiledBinary = findCompiledBinary();
+if (compiledBinary) {
+  // Run the compiled binary directly — no Bun needed
+  const child = spawn(compiledBinary, [], {
+    env,
+    stdio: "inherit",
+    shell: false,
+  });
+
+  child.on("error", (err) => {
+    console.error("Error starting apteva:", err.message);
+    process.exit(1);
+  });
 
-// Spawn the server
-const child = spawn(runtime, runtimeArgs, {
-  env,
-  stdio: "inherit",
-  shell: false,
-});
+  child.on("exit", (code) => process.exit(code || 0));
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+} else {
+  // Fall back to source mode
+  const sourceEntry = findSourceEntry();
 
-child.on("error", (err) => {
-  if (err.code === "ENOENT" && runtime === "bun") {
-    // Fallback to node if bun not found
-    const nodeChild = spawn("node", [entryPoint], {
+  if (sourceEntry && hasBun()) {
+    // Run with Bun (development mode)
+    const child = spawn("bun", ["--silent", sourceEntry], {
       env,
       stdio: "inherit",
       shell: false,
     });
-    nodeChild.on("error", (nodeErr) => {
-      console.error("Error starting server:", nodeErr.message);
+
+    child.on("error", (err) => {
+      console.error("Error starting apteva:", err.message);
       process.exit(1);
     });
+
+    child.on("exit", (code) => process.exit(code || 0));
+    process.on("SIGINT", () => child.kill("SIGINT"));
+    process.on("SIGTERM", () => child.kill("SIGTERM"));
   } else {
-    console.error("Error starting server:", err.message);
+    // No binary, no Bun — show helpful error
+    console.error("Error: Could not find apteva binary for your platform.");
+    console.error("");
+    console.error("Options:");
+    console.error("  1. Install Bun (recommended for development):");
+    console.error("     curl -fsSL https://bun.sh/install | bash        # macOS/Linux");
+    console.error("     powershell -c \"irm bun.sh/install.ps1 | iex\"    # Windows");
+    console.error("");
+    console.error("  2. Reinstall apteva (to get the platform binary):");
+    console.error("     npm install -g apteva");
     process.exit(1);
   }
-});
-
-child.on("exit", (code) => {
-  process.exit(code || 0);
-});
-
-// Handle termination
-process.on("SIGINT", () => {
-  child.kill("SIGINT");
-});
-
-process.on("SIGTERM", () => {
-  child.kill("SIGTERM");
-});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apteva",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "description": "Run AI agents locally. Multi-provider support for Claude, GPT, Gemini, Llama, and more.",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,15 +12,20 @@
     "dev": "bun run --watch src/server.ts",
     "build": "bun run build.ts",
     "build:cli": "bun build ./src/cli.ts --outdir ./dist --target node",
+    "compile": "bun run build && bun run scripts/compile.ts",
+    "compile:single": "bun run build && bun run scripts/compile.ts --single",
     "start": "bun run src/server.ts",
     "tui": "bun run src/tui/index.tsx",
+    "postinstall": "node scripts/postinstall.mjs",
     "prepublishOnly": "bun run build"
   },
   "files": [
     "bin/apteva.js",
+    "scripts/postinstall.mjs",
     "dist/*.js",
     "dist/*.css",
     "dist/*.html",
+    "dist/*.png",
     "src",
     "LICENSE",
     "README.md"
@@ -70,6 +75,11 @@
     "react-dom": "19"
   },
   "optionalDependencies": {
+    "@apteva/apteva-darwin-arm64": "0.4.32",
+    "@apteva/apteva-darwin-x64": "0.4.32",
+    "@apteva/apteva-linux-arm64": "0.4.32",
+    "@apteva/apteva-linux-x64": "0.4.32",
+    "@apteva/apteva-win32-x64": "0.4.32",
     "@apteva/agent-darwin-arm64": "^1.33.73",
     "@apteva/agent-darwin-x64": "^1.33.73",
     "@apteva/agent-linux-arm64": "^1.33.73",

package/scripts/postinstall.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script for apteva npm package.
+ * Detects platform and creates a symlink to the compiled binary
+ * from the matching @apteva/apteva-{platform}-{arch} package.
+ *
+ * This runs with plain Node.js — no Bun required.
+ */
+
+import { existsSync, symlinkSync, unlinkSync, mkdirSync, copyFileSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, "..");
+const BIN_DIR = join(ROOT, "bin");
+const require = createRequire(import.meta.url);
+
+// Map Node.js platform/arch to our package naming
+const PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "win32",
+};
+
+const ARCH_MAP = {
+  x64: "x64",
+  arm64: "arm64",
+};
+
+function main() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+
+  if (!platform || !arch) {
+    console.log(`apteva: No binary available for ${process.platform}-${process.arch}`);
+    console.log("apteva: You can still run with Bun: bun apteva");
+    process.exit(0);
+  }
+
+  const packageName = `@apteva/apteva-${platform}-${arch}`;
+
+  // Try to find the platform binary package
+  let binaryPath;
+  try {
+    binaryPath = require(packageName);
+  } catch {
+    // Package not installed (npm skips optionalDeps that don't match platform)
+    // Also try direct path resolution
+    const directPaths = [
+      join(ROOT, "node_modules", packageName, platform === "win32" ? "apteva.exe" : "apteva"),
+      join(ROOT, "..", packageName, platform === "win32" ? "apteva.exe" : "apteva"),
+    ];
+
+    for (const p of directPaths) {
+      if (existsSync(p)) {
+        binaryPath = p;
+        break;
+      }
+    }
+  }
+
+  if (!binaryPath || !existsSync(binaryPath)) {
+    // No compiled binary — that's OK, user can run with Bun
+    process.exit(0);
+  }
+
+  // Ensure bin directory exists
+  mkdirSync(BIN_DIR, { recursive: true });
+
+  const targetName = process.platform === "win32" ? "apteva-server.exe" : "apteva-server";
+  const targetPath = join(BIN_DIR, targetName);
+
+  // Remove existing link/file
+  try {
+    unlinkSync(targetPath);
+  } catch {
+    // Doesn't exist, that's fine
+  }
+
+  // Create symlink (or copy on Windows)
+  try {
+    if (process.platform === "win32") {
+      copyFileSync(binaryPath, targetPath);
+    } else {
+      symlinkSync(binaryPath, targetPath);
+      chmodSync(binaryPath, 0o755);
+    }
+  } catch (err) {
+    // Symlink may fail on some systems — try copy as fallback
+    try {
+      copyFileSync(binaryPath, targetPath);
+      chmodSync(targetPath, 0o755);
+    } catch {
+      // Silent fail — bin/apteva.js will find the binary via require() at runtime
+      process.exit(0);
+    }
+  }
+}
+
+main();

package/src/routes/static.ts

@@ -1,11 +1,12 @@
 import { join } from "path";
 import { existsSync, statSync } from "fs";
 
-// Find dist directory - handle both development and npx contexts
+// Find dist directory - handle development, npx, and compiled binary contexts
 function findDistDir(): string {
   const candidates = [
     join(import.meta.dir, "../../dist"),
     join(import.meta.dir, "../dist"),
+    join(import.meta.dir, "dist"),    // compiled binary: dist/ alongside the executable
     join(process.cwd(), "dist"),
   ];