v0.2.10: Fix Windows compiled binary crash on startup (reported by @LT1428 and @tom Ramen)

On Windows, Bun.main in compiled binaries returns a virtual path like "/"
instead of the actual executable path. dirname("/") on Windows gives "\",
causing SessionManager to try mkdirSync("\") which fails with EPERM.

Fix: extract path resolution into paths.ts using process.execPath for
compiled binaries with fallback to process.cwd(). Includes isRootPath()
safety check to reject root-like directories.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: SpaceMolt DevTeam

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spacemolt/commander",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "type": "module",
   "scripts": {
     "start": "bun run src/commander.ts",

src/commander.ts

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
+import { join } from "path";
 import type { Context, Message } from "@mariozechner/pi-ai";
 import { resolveModel } from "./model.js";
 import { SpaceMoltAPI } from "./api.js";
@@ -8,14 +8,13 @@ import { allTools } from "./tools.js";
 import { fetchGameCommands, formatCommandList } from "./schema.js";
 import { runAgentTurn, generateSessionHandoff, type CompactionState } from "./loop.js";
 import { log, logError, setDebug, logNotifications, formatNotifications } from "./ui.js";
+import { resolveProjectRoot } from "./paths.js";
 import DEFAULT_PROMPT from "../prompt.md" with { type: "text" };
 
-// When running from source (bun run src/commander.ts), Bun.main is the .ts file
-// so dirname(dirname) correctly gives the repo root.
-// When running as a compiled binary, Bun.main is the binary itself,
-// so we only need dirname once to get the containing directory.
-const isSource = Bun.main.endsWith(".ts") || Bun.main.endsWith(".js");
-const PROJECT_ROOT = isSource ? dirname(dirname(Bun.main)) : dirname(Bun.main);
+// Resolve project root safely. In compiled binaries on Windows, Bun.main may
+// return a virtual path like "/" which breaks path resolution. resolveProjectRoot
+// handles this by preferring process.execPath and falling back to process.cwd().
+const PROJECT_ROOT = resolveProjectRoot(Bun.main, process.execPath, process.cwd());
 const TURN_INTERVAL = 2000; // ms between turns
 
 function printUsage(): void {

src/paths.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect } from "bun:test";
+import { resolveProjectRoot, isRootPath } from "./paths.js";
+
+describe("isRootPath", () => {
+  test("detects Unix root /", () => {
+    expect(isRootPath("/")).toBe(true);
+  });
+
+  test("detects backslash root (Windows)", () => {
+    expect(isRootPath("\\")).toBe(true);
+  });
+
+  test("detects Windows drive roots", () => {
+    expect(isRootPath("C:\\")).toBe(true);
+    expect(isRootPath("D:\\")).toBe(true);
+    expect(isRootPath("C:")).toBe(true);
+  });
+
+  test("detects empty string as root-like", () => {
+    expect(isRootPath("")).toBe(true);
+  });
+
+  test("detects multiple slashes as root", () => {
+    expect(isRootPath("//")).toBe(true);
+    expect(isRootPath("\\\\")).toBe(true);
+  });
+
+  test("rejects normal directories", () => {
+    expect(isRootPath("/home/user/project")).toBe(false);
+    expect(isRootPath("/Users/clodpod/projects")).toBe(false);
+    expect(isRootPath("E:\\code\\commander")).toBe(false);
+  });
+});
+
+describe("resolveProjectRoot", () => {
+  test("uses dirname(dirname(Bun.main)) for source .ts files", () => {
+    const result = resolveProjectRoot(
+      "/home/user/commander/src/commander.ts",
+      "/usr/bin/bun",
+      "/home/user"
+    );
+    expect(result).toBe("/home/user/commander");
+  });
+
+  test("uses dirname(dirname(Bun.main)) for source .js files", () => {
+    const result = resolveProjectRoot(
+      "/home/user/commander/src/commander.js",
+      "/usr/bin/bun",
+      "/home/user"
+    );
+    expect(result).toBe("/home/user/commander");
+  });
+
+  test("uses execPath for compiled binary", () => {
+    const result = resolveProjectRoot(
+      "/internal/bundle",  // Bun.main in compiled binary (not .ts/.js)
+      "/home/user/commander/commander-linux-x64",
+      "/home/user"
+    );
+    expect(result).toBe("/home/user/commander");
+  });
+
+  test("BUG REPRO: does NOT return root when Bun.main is '/' in compiled binary", () => {
+    // This is the exact bug: on Windows compiled binaries, Bun.main returns "/"
+    // which causes dirname("/") -> "\" on Windows, leading to mkdir("\") -> EPERM
+    const result = resolveProjectRoot(
+      "/",  // Bun.main returns "/" in compiled binary on Windows
+      "/home/user/commander/commander-exe",  // but execPath is valid
+      "/home/user"
+    );
+    // Should NOT be "/" or "\" — should use execPath instead
+    expect(isRootPath(result)).toBe(false);
+    expect(result).toBe("/home/user/commander");
+  });
+
+  test("falls back to cwd when both Bun.main and execPath are root paths", () => {
+    const result = resolveProjectRoot(
+      "/",
+      "/",
+      "/home/user/commander"
+    );
+    expect(result).toBe("/home/user/commander");
+  });
+
+  test("falls back to cwd when both paths are empty", () => {
+    const result = resolveProjectRoot(
+      "",
+      "",
+      "/home/user/commander"
+    );
+    expect(result).toBe("/home/user/commander");
+  });
+});

src/paths.ts

@@ -0,0 +1,62 @@
+import { dirname, resolve, parse } from "path";
+
+/**
+ * Resolve the project root directory.
+ *
+ * When running from source (bun run src/commander.ts), Bun.main is the .ts
+ * file so we go up two directories (src/ -> repo root).
+ *
+ * When running as a compiled binary, Bun.main may return an internal virtual
+ * path (e.g. "/" on Windows) instead of the real executable path. We use
+ * process.execPath as the primary source for compiled binaries, falling back
+ * to process.cwd() if that also fails.
+ */
+export function resolveProjectRoot(bunMain: string, execPath: string, cwd: string): string {
+  const isSource = bunMain.endsWith(".ts") || bunMain.endsWith(".js");
+
+  if (isSource) {
+    return dirname(dirname(bunMain));
+  }
+
+  // Compiled binary: prefer process.execPath over Bun.main since Bun.main
+  // may return a virtual filesystem path in compiled binaries.
+  // Try execPath first, then bunMain, then fall back to cwd.
+  for (const candidate of [execPath, bunMain]) {
+    if (candidate) {
+      const dir = dirname(resolve(candidate));
+      // Sanity check: reject root-only paths (e.g. "/" or "\" or "C:\")
+      if (!isRootPath(dir)) {
+        return dir;
+      }
+    }
+  }
+
+  // Last resort: use current working directory
+  return cwd;
+}
+
+/**
+ * Check if a path is a filesystem root (e.g. "/", "\", "C:\", "D:/").
+ * We never want to use a root as PROJECT_ROOT since creating subdirectories
+ * there will fail with permission errors.
+ *
+ * Works cross-platform: handles both "/" (posix) and "\" / "C:\" (Windows).
+ */
+export function isRootPath(p: string): boolean {
+  if (!p) return true;
+
+  // Normalize: trim trailing separators for comparison
+  const normalized = p.replace(/[/\\]+$/, "");
+
+  // Empty after stripping means it was purely slashes (e.g. "/" or "\")
+  if (normalized === "") return true;
+
+  // Windows drive root: "C:" or "D:" (after stripping trailing separator)
+  if (/^[A-Za-z]:$/.test(normalized)) return true;
+
+  // Use path.parse as additional check (works for the native platform)
+  const parsed = parse(p);
+  if (parsed.base === "" || p === parsed.root) return true;
+
+  return false;
+}