attempt to fix windows ui

ui/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goose-app",
   "productName": "Goose",
-  "version": "1.0.4",
+  "version": "1.0.4b",
   "description": "Goose App",
   "main": ".vite/build/main.js",
   "scripts": {

ui/desktop/src/goosed.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import { createServer } from 'net';
 import os from 'node:os';
+import path from 'node:path';
 import { getBinaryPath } from './utils/binaryPath';
 import log from './utils/logger';
 import { ChildProcessByStdio } from 'node:child_process';
@@ -56,9 +57,13 @@ export const startGoosed = async (
 ): Promise<[number, string, ChildProcessByStdio<null, Readable, Readable>]> => {
   // we default to running goosed in home dir - if not specified
   const homeDir = os.homedir();
+  const isWindows = process.platform === 'win32';
+
+  // Ensure dir is properly normalized for the platform
   if (!dir) {
     dir = homeDir;
   }
+  dir = path.normalize(dir);
 
   // Get the goosed binary path using the shared utility
   let goosedPath = getBinaryPath(app, 'goosed');
@@ -72,34 +77,48 @@ export const startGoosed = async (
     HOME: homeDir,
     // Set USERPROFILE for Windows
     USERPROFILE: homeDir,
-
+    // Set APPDATA for Windows
+    APPDATA: process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'),
+    // Set LOCAL_APPDATA for Windows
+    LOCALAPPDATA: process.env.LOCALAPPDATA || path.join(homeDir, 'AppData', 'Local'),
+    // Set PATH to include the binary directory
+    PATH: `${path.dirname(goosedPath)}${path.delimiter}${process.env.PATH}`,
     // start with the port specified
     GOOSE_PORT: String(port),
-
     GOOSE_SERVER__SECRET_KEY: process.env.GOOSE_SERVER__SECRET_KEY,
-
     // Add any additional environment variables passed in
     ...env,
   };
 
   // Merge parent environment with additional environment variables
   const processEnv = { ...process.env, ...additionalEnv };
 
-  // Configure spawn options with Windows-specific settings
-  const isWindows = process.platform === 'win32';
-
   // Add detailed logging for troubleshooting
   log.info(`Process platform: ${process.platform}`);
   log.info(`Process cwd: ${process.cwd()}`);
+  log.info(`Target working directory: ${dir}`);
   log.info(`Environment HOME: ${processEnv.HOME}`);
   log.info(`Environment USERPROFILE: ${processEnv.USERPROFILE}`);
+  log.info(`Environment APPDATA: ${processEnv.APPDATA}`);
+  log.info(`Environment LOCALAPPDATA: ${processEnv.LOCALAPPDATA}`);
+  log.info(`Environment PATH: ${processEnv.PATH}`);
 
   // Ensure proper executable path on Windows
   if (isWindows && !goosedPath.toLowerCase().endsWith('.exe')) {
     goosedPath += '.exe';
   }
   log.info(`Binary path resolved to: ${goosedPath}`);
 
+  // Verify binary exists
+  try {
+    const fs = require('fs');
+    const stats = fs.statSync(goosedPath);
+    log.info(`Binary exists: ${stats.isFile()}`);
+  } catch (error) {
+    log.error(`Binary not found at ${goosedPath}:`, error);
+    throw new Error(`Binary not found at ${goosedPath}`);
+  }
+
   const spawnOptions = {
     cwd: dir,
     env: processEnv,
@@ -112,6 +131,9 @@ export const startGoosed = async (
     shell: false,
   };
 
+  // Log spawn options for debugging
+  log.info('Spawn options:', JSON.stringify(spawnOptions, null, 2));
+
   // Spawn the goosed process
   const goosedProcess = spawn(goosedPath, ['agent'], spawnOptions);
 

ui/desktop/src/renderer.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import ReactDOM from 'react-dom/client';
-import { BrowserRouter as Router } from 'react-router-dom';
+import { HashRouter as Router } from 'react-router-dom';
 import App from './App';
 
 // Error Boundary Component

ui/desktop/src/utils/binaryPath.ts

@@ -1,17 +1,49 @@
 import path from 'node:path';
+import fs from 'node:fs';
 import Electron from 'electron';
+import log from './logger';
 
 export const getBinaryPath = (app: Electron.App, binaryName: string): string => {
   const isDev = process.env.NODE_ENV === 'development';
   const isPackaged = app.isPackaged;
   const isWindows = process.platform === 'win32';
   const executableName = isWindows ? `${binaryName}.exe` : binaryName;
 
+  // List of possible paths to check
+  const possiblePaths = [];
+
   if (isDev && !isPackaged) {
-    // In development, use the absolute path from the project root
-    return path.join(process.cwd(), 'src', 'bin', executableName);
+    // In development, check multiple possible locations
+    possiblePaths.push(
+      path.join(process.cwd(), 'src', 'bin', executableName),
+      path.join(process.cwd(), 'bin', executableName),
+      path.join(process.cwd(), '..', '..', 'target', 'release', executableName)
+    );
   } else {
-    // In production, always use resources/bin path for consistency
-    return path.join(process.resourcesPath, 'bin', executableName);
+    // In production, check resources paths
+    possiblePaths.push(
+      path.join(process.resourcesPath, 'bin', executableName),
+      path.join(app.getAppPath(), 'resources', 'bin', executableName)
+    );
   }
+
+  // Log all paths we're checking
+  log.info('Checking binary paths:', possiblePaths);
+
+  // Try each path and return the first one that exists
+  for (const binPath of possiblePaths) {
+    try {
+      if (fs.existsSync(binPath)) {
+        log.info(`Found binary at: ${binPath}`);
+        return binPath;
+      }
+    } catch (error) {
+      log.error(`Error checking path ${binPath}:`, error);
+    }
+  }
+
+  // If we get here, we couldn't find the binary
+  const error = `Could not find ${binaryName} binary in any of the expected locations: ${possiblePaths.join(', ')}`;
+  log.error(error);
+  throw new Error(error);
 };