@castlekit/castle 0.3.2 → 0.4.1

package/src/cli/onboarding.ts

@@ -3,7 +3,7 @@ import pc from "picocolors";
 import { execSync } from "child_process";
 import { randomUUID } from "crypto";
 import WebSocket from "ws";
-import { readFileSync } from "fs";
+import { readFileSync, existsSync } from "fs";
 import { resolve as resolvePath, dirname } from "path";
 import { fileURLToPath } from "url";
 import {
@@ -292,6 +292,20 @@ async function promptManualGateway(): Promise<{
 
 export async function runOnboarding(): Promise<void> {
 
+  // Node 22+ is required for native fetch, compile cache, and modern APIs
+  const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeVersion < 22) {
+    p.intro(BLUE_BOLD("Castle Setup"));
+    p.log.error(
+      pc.red(`Node.js 22 or higher is required (you have v${process.versions.node}).`) +
+      "\n" +
+      pc.dim("  Install it from https://nodejs.org or via nvm:\n") +
+      BLUE("  nvm install 22 && nvm use 22")
+    );
+    p.outro(pc.dim("Then run castle setup again."));
+    return;
+  }
+
   p.intro(BLUE_BOLD("Castle Setup"));
 
   p.note(
@@ -341,28 +355,31 @@ export async function runOnboarding(): Promise<void> {
       const installSpinner = p.spinner();
       installSpinner.start("Installing OpenClaw...");
 
+      const installCmd = process.platform === "win32"
+        ? 'powershell -NoProfile -ExecutionPolicy Bypass -Command "& { iwr -useb https://openclaw.ai/install.ps1 | iex } -NoOnboard"'
+        : 'curl -fsSL --proto "=https" --tlsv1.2 https://openclaw.ai/install.sh | bash -s -- --no-onboard --no-prompt';
+
       try {
-        execSync(
-          'curl -fsSL --proto "=https" --tlsv1.2 https://openclaw.ai/install.sh | bash -s -- --no-onboard --no-prompt',
-          { stdio: "pipe", timeout: 120000 }
-        );
+        execSync(installCmd, { stdio: "pipe", timeout: 120000 });
         installSpinner.stop(BLUE("✔ OpenClaw installed"));
       } catch (error) {
         installSpinner.stop(pc.red("OpenClaw installation failed"));
+        const manualCmd = process.platform === "win32"
+          ? "iwr -useb https://openclaw.ai/install.ps1 | iex"
+          : "curl -fsSL https://openclaw.ai/install.sh | bash";
         p.note(
-          `Install OpenClaw manually:\n${BLUE_LIGHT(
-            "curl -fsSL https://openclaw.ai/install.sh | bash"
-          )}\n\nThen run: ${BLUE_LIGHT("castle setup")}`,
+          `Install OpenClaw manually:\n${BLUE_LIGHT(manualCmd)}\n\nThen run: ${BLUE_LIGHT("castle setup")}`,
           BLUE_BOLD("Manual Install")
         );
         p.outro("Come back when OpenClaw is installed!");
         process.exit(1);
       }
     } else {
+      const manualCmd = process.platform === "win32"
+        ? "iwr -useb https://openclaw.ai/install.ps1 | iex"
+        : "curl -fsSL https://openclaw.ai/install.sh | bash";
       p.note(
-        `Install OpenClaw:\n${BLUE_LIGHT(
-          "curl -fsSL https://openclaw.ai/install.sh | bash"
-        )}\n\nThen come back and run:\n${BLUE_LIGHT("castle setup")}`,
+        `Install OpenClaw:\n${BLUE_LIGHT(manualCmd)}\n\nThen come back and run:\n${BLUE_LIGHT("castle setup")}`,
         BLUE_BOLD("Install OpenClaw First")
       );
       p.outro("See you soon!");
@@ -510,7 +527,6 @@ export async function runOnboarding(): Promise<void> {
   };
 
   writeConfig(config);
-  serverSpinner.message("Building Castle...");
 
   const { spawn, exec, execSync: execSyncChild } = await import("child_process");
   const { join } = await import("path");
@@ -521,39 +537,122 @@ export async function runOnboarding(): Promise<void> {
   const logsDir = join(castleDir, "logs");
   mkDir(logsDir, { recursive: true });
 
-  // Build for production (async so the spinner can animate)
-  const buildOk = await new Promise<boolean>((resolve) => {
-    const child = exec("npm run build", {
-      cwd: PROJECT_ROOT,
-      timeout: 120000,
+  // Check if the app was pre-built (npm publish ships .next/standalone/)
+  const standaloneServer = join(PROJECT_ROOT, ".next", "standalone", "server.js");
+  const hasPrebuilt = existsSync(standaloneServer);
+
+  if (hasPrebuilt) {
+    serverSpinner.message("Pre-built Castle detected — skipping build...");
+  } else {
+    // Dev / git-clone install — need to build from source
+    serverSpinner.message("Building Castle...");
+
+    const buildLogPath = join(logsDir, "build.log");
+
+    const buildOk = await new Promise<boolean>((resolve) => {
+      let output = "";
+      const child = exec("npm run build", {
+        cwd: PROJECT_ROOT,
+        timeout: 180000,
+      });
+      child.stdout?.on("data", (d: string) => { output += d; });
+      child.stderr?.on("data", (d: string) => { output += d; });
+      child.on("close", (code) => {
+        // Write full output to log file
+        try { writeFile(buildLogPath, output); } catch { /* ignore */ }
+        resolve(code === 0);
+      });
+      child.on("error", (err) => {
+        try { writeFile(buildLogPath, output + "\n" + String(err)); } catch { /* ignore */ }
+        resolve(false);
+      });
     });
-    child.on("close", (code) => resolve(code === 0));
-    child.on("error", () => resolve(false));
-  });
 
-  if (!buildOk) {
-    serverSpinner.stop(pc.red("Build failed"));
-    p.outro(pc.dim(`Try running ${BLUE("npm run build")} manually in the castle directory.`));
-    return;
+    if (!buildOk) {
+      serverSpinner.stop(pc.red("Build failed"));
+      // Show the last 20 lines of build output so the user can see what went wrong
+      try {
+        const log = readF(buildLogPath, "utf-8");
+        const lines = log.split("\n");
+        const tail = lines.slice(-20).join("\n");
+        p.log.error(pc.dim("Last 20 lines of build output:\n") + tail);
+      } catch { /* log unavailable */ }
+      p.outro(
+        pc.dim(`Full build log: ${BLUE(`~/.castle/logs/build.log`)}\n`) +
+        pc.dim(`Try running ${BLUE("npm run build")} manually in the castle directory.`)
+      );
+      return;
+    }
   }
 
   serverSpinner.message("Starting Castle...");
 
-  // Find node and next paths for the service
+  // Find node path and determine how to start the server
   const nodePath = process.execPath;
   const nextBin = join(PROJECT_ROOT, "node_modules", ".bin", "next");
 
+  // Use standalone server.js when pre-built (global installs), fall back to next start
+  const useStandalone = existsSync(join(PROJECT_ROOT, ".next", "standalone", "server.js"));
+  const serverScript = useStandalone
+    ? join(PROJECT_ROOT, ".next", "standalone", "server.js")
+    : null;
+
+  // Build the program args for the service and direct spawn
+  const serverArgs = serverScript
+    ? [serverScript]
+    : [nextBin, "start", "-p", String(config.server?.port || 3333)];
+
+  // Environment for standalone mode needs PORT, HOSTNAME, and NODE_PATH
+  // NODE_PATH is critical: the standalone bundle ships without node_modules
+  // (native modules like better-sqlite3 are platform-specific and can't be
+  // bundled cross-platform). NODE_PATH tells Node to resolve packages from
+  // the package root's node_modules/ where npm installed correct binaries.
+  const serverEnv: Record<string, string> = {
+    NODE_ENV: "production",
+    PATH: process.env.PATH || "",
+  };
+  if (serverScript) {
+    serverEnv.PORT = String(config.server?.port || 3333);
+    serverEnv.HOSTNAME = "127.0.0.1";
+    serverEnv.NODE_PATH = join(PROJECT_ROOT, "node_modules");
+  }
+
   // Castle port from config or default
   const castlePort = String(config.server?.port || 3333);
 
   // Write PID file helper
   const pidFile = join(castleDir, "server.pid");
+  const isWin = process.platform === "win32";
+
+  // Stop existing service FIRST — otherwise the service manager respawns
+  // the old server immediately after we kill it, stealing the port.
+  if (process.platform === "darwin") {
+    const plistPath = join(home(), "Library", "LaunchAgents", "com.castlekit.castle.plist");
+    try {
+      execSyncChild(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore", timeout: 10000 });
+    } catch { /* no existing service */ }
+  } else if (process.platform === "linux") {
+    try {
+      execSyncChild("systemctl --user stop castle.service 2>/dev/null", { stdio: "ignore", timeout: 10000 });
+    } catch { /* no existing service */ }
+  } else if (isWin) {
+    try {
+      execSyncChild('schtasks /End /TN "CastleServer" 2>nul', { stdio: "ignore", timeout: 10000 });
+    } catch { /* no existing task */ }
+    try {
+      execSyncChild('schtasks /Delete /TN "CastleServer" /F 2>nul', { stdio: "ignore", timeout: 10000 });
+    } catch { /* no existing task */ }
+  }
 
   // Kill any existing Castle server (by PID file)
   try {
     const existingPid = parseInt(readF(pidFile, "utf-8").trim(), 10);
     if (Number.isInteger(existingPid) && existingPid > 0) {
-      process.kill(existingPid);
+      if (isWin) {
+        try { execSyncChild(`taskkill /PID ${existingPid} /F 2>nul`, { stdio: "ignore", timeout: 5000 }); } catch { /* ignore */ }
+      } else {
+        process.kill(existingPid);
+      }
       for (let i = 0; i < 30; i++) {
         try {
           process.kill(existingPid, 0);
@@ -568,14 +667,35 @@ export async function runOnboarding(): Promise<void> {
   }
 
   // Kill anything else on the target port
-  try {
-    execSyncChild(`lsof -ti:${castlePort} | xargs kill -9 2>/dev/null`, {
-      stdio: "ignore",
-      timeout: 5000,
-    });
-    await new Promise((r) => setTimeout(r, 500));
-  } catch {
-    // Nothing on port or lsof not available
+  if (isWin) {
+    try {
+      const netstatOut = execSyncChild(
+        `netstat -ano | findstr ":${castlePort} " | findstr "LISTENING"`,
+        { encoding: "utf-8", timeout: 5000 }
+      ).toString();
+      const pids = new Set<string>();
+      for (const line of netstatOut.split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parts[parts.length - 1];
+        if (pid && /^\d+$/.test(pid) && pid !== "0") pids.add(pid);
+      }
+      for (const pid of pids) {
+        try { execSyncChild(`taskkill /PID ${pid} /F 2>nul`, { stdio: "ignore", timeout: 5000 }); } catch { /* ignore */ }
+      }
+      if (pids.size > 0) await new Promise((r) => setTimeout(r, 500));
+    } catch {
+      // Nothing on port or netstat not available
+    }
+  } else {
+    try {
+      execSyncChild(`lsof -ti:${castlePort} | xargs kill -9 2>/dev/null`, {
+        stdio: "ignore",
+        timeout: 5000,
+      });
+      await new Promise((r) => setTimeout(r, 500));
+    } catch {
+      // Nothing on port or lsof not available
+    }
   }
 
   // Escape XML special characters for plist values
@@ -587,6 +707,12 @@ export async function runOnboarding(): Promise<void> {
     const plistDir = join(home(), "Library", "LaunchAgents");
     mkDir(plistDir, { recursive: true });
     const plistPath = join(plistDir, "com.castlekit.castle.plist");
+    const plistArgs = [nodePath, ...serverArgs]
+      .map((a) => `        <string>${xmlEscape(a)}</string>`)
+      .join("\n");
+    const plistEnvEntries = Object.entries(serverEnv)
+      .map(([k, v]) => `        <key>${xmlEscape(k)}</key>\n        <string>${xmlEscape(v)}</string>`)
+      .join("\n");
     const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -595,11 +721,7 @@ export async function runOnboarding(): Promise<void> {
     <string>com.castlekit.castle</string>
     <key>ProgramArguments</key>
     <array>
-        <string>${xmlEscape(nodePath)}</string>
-        <string>${xmlEscape(nextBin)}</string>
-        <string>start</string>
-        <string>-p</string>
-        <string>${xmlEscape(castlePort)}</string>
+${plistArgs}
     </array>
     <key>WorkingDirectory</key>
     <string>${xmlEscape(PROJECT_ROOT)}</string>
@@ -616,16 +738,11 @@ export async function runOnboarding(): Promise<void> {
     <string>${xmlEscape(logsDir)}/server.err</string>
     <key>EnvironmentVariables</key>
     <dict>
-        <key>NODE_ENV</key>
-        <string>production</string>
-        <key>PATH</key>
-        <string>${xmlEscape(process.env.PATH || "")}</string>
+${plistEnvEntries}
     </dict>
 </dict>
 </plist>`;
-    try {
-      execSyncChild(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore", timeout: 10000 });
-    } catch { /* ignore */ }
+    // Service was already unloaded above — just write new plist and load
     writeFile(plistPath, plist);
     try {
       execSyncChild(`launchctl load "${plistPath}"`, { stdio: "ignore", timeout: 10000 });
@@ -636,17 +753,20 @@ export async function runOnboarding(): Promise<void> {
     const systemdDir = join(home(), ".config", "systemd", "user");
     mkDir(systemdDir, { recursive: true });
     const servicePath = join(systemdDir, "castle.service");
+    const systemdEnvLines = Object.entries(serverEnv)
+      .map(([k, v]) => `Environment=${k}=${v}`)
+      .join("\n");
+    const execStartCmd = [nodePath, ...serverArgs].join(" ");
     const service = `[Unit]
 Description=Castle - The multi-agent workspace
 After=network.target
 
 [Service]
-ExecStart=${nodePath} ${nextBin} start -p ${castlePort}
+ExecStart=${execStartCmd}
 WorkingDirectory=${PROJECT_ROOT}
 Restart=on-failure
 RestartSec=5
-Environment=NODE_ENV=production
-Environment=PATH=${process.env.PATH}
+${systemdEnvLines}
 
 [Install]
 WantedBy=default.target
@@ -657,6 +777,32 @@ WantedBy=default.target
     } catch {
       // Non-fatal
     }
+  } else if (isWin) {
+    // Windows: use Task Scheduler to run Castle at logon
+    // Build a batch wrapper that sets environment variables and starts the server
+    const batPath = join(castleDir, "start-server.bat");
+    const envLines = Object.entries(serverEnv)
+      .map(([k, v]) => `set "${k}=${v}"`)
+      .join("\r\n");
+    const batContent = `@echo off\r\n${envLines}\r\ncd /d "${PROJECT_ROOT}"\r\n"${nodePath}" ${serverArgs.map((a) => `"${a}"`).join(" ")}\r\n`;
+    writeFile(batPath, batContent);
+
+    // Task was already deleted above — create fresh
+    try {
+      execSyncChild(
+        `schtasks /Create /TN "CastleServer" /TR "\\"${batPath}\\"" /SC ONLOGON /RL HIGHEST /F 2>nul`,
+        { stdio: "ignore", timeout: 10000 }
+      );
+    } catch {
+      // Non-fatal — fall back to spawning directly
+    }
+
+    // Also start the task now
+    try {
+      execSyncChild('schtasks /Run /TN "CastleServer" 2>nul', { stdio: "ignore", timeout: 10000 });
+    } catch {
+      // Non-fatal
+    }
   }
 
   // If no service manager started it, spawn directly
@@ -664,10 +810,11 @@ WantedBy=default.target
     await fetch(`http://localhost:${castlePort}`);
   } catch {
     // Server not up yet — spawn it directly as fallback
-    const server = spawn(nodePath, [nextBin, "start", "-p", castlePort], {
+    const server = spawn(nodePath, serverArgs, {
       cwd: PROJECT_ROOT,
       stdio: ["ignore", "ignore", "ignore"],
       detached: true,
+      env: { ...process.env, ...serverEnv },
     });
     if (server.pid != null) {
       writeFile(pidFile, String(server.pid));