neoagent 2.1.4 → 2.1.6

package/server/routes/android.js

@@ -17,7 +17,7 @@ router.get('/status', async (req, res) => {
 router.post('/start', async (req, res) => {
   try {
     const controller = req.app.locals.androidController;
-    res.json(await controller.startEmulator(req.body || {}));
+    res.json(await controller.requestStartEmulator(req.body || {}));
   } catch (err) {
     res.status(500).json({ error: sanitizeError(err) });
   }

package/server/services/ai/engine.js

@@ -18,7 +18,7 @@ function generateTitle(task) {
   return cleaned.slice(0, 90);
 }
 
-async function getProviderForUser(userId, task = '', isSubagent = false, modelOverride = null) {
+async function getProviderForUser(userId, task = '', isSubagent = false, modelOverride = null, providerConfig = {}) {
   const { getSupportedModels, createProviderInstance } = require('./models');
   const models = await getSupportedModels(userId);
 
@@ -68,7 +68,7 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
     if (requested && requested.available !== false && enabledIds.includes(requested.id)) {
       selectedModelDef = requested;
       return {
-        provider: createProviderInstance(selectedModelDef.provider, userId),
+        provider: createProviderInstance(selectedModelDef.provider, userId, providerConfig),
         model: selectedModelDef.id,
         providerName: selectedModelDef.provider
       };
@@ -102,7 +102,7 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
   }
 
   return {
-    provider: createProviderInstance(selectedModelDef.provider, userId),
+    provider: createProviderInstance(selectedModelDef.provider, userId, providerConfig),
     model: selectedModelDef.id,
     providerName: selectedModelDef.provider
   };
@@ -271,7 +271,6 @@ class AgentEngine {
     const triggerType = options.triggerType || 'user';
     ensureDefaultAiSettings(userId);
     const aiSettings = getAiSettings(userId);
-    const { provider, model, providerName } = await getProviderForUser(userId, userMessage, triggerType === 'subagent', _modelOverride);
 
     const runId = options.runId || uuidv4();
     const conversationId = options.conversationId;
@@ -280,6 +279,23 @@ class AgentEngine {
     const historyWindow = aiSettings.chat_history_window;
     const toolReplayBudget = aiSettings.tool_replay_budget_chars;
     const maxIterations = this.getIterationLimit(triggerType, aiSettings);
+    const providerStatusConfig = {
+      onStatus: (status) => {
+        if (!status?.message) return;
+        this.emit(userId, 'run:interim', {
+          runId,
+          message: status.message,
+          phase: status.phase
+        });
+      }
+    };
+    const { provider, model, providerName } = await getProviderForUser(
+      userId,
+      userMessage,
+      triggerType === 'subagent',
+      _modelOverride,
+      providerStatusConfig
+    );
 
     const runTitle = generateTitle(userMessage);
     db.prepare(`INSERT OR REPLACE INTO agent_runs(id, user_id, title, status, trigger_type, trigger_source, model)
@@ -385,7 +401,13 @@ class AgentEngine {
             console.error(`[Engine] Model call failed (${model}):`, err.message);
             if (retryForFallback && aiSettings.fallback_model_id && aiSettings.fallback_model_id !== model) {
               console.log(`[Engine] Attempting fallback to: ${aiSettings.fallback_model_id}`);
-              const fallback = await getProviderForUser(userId, userMessage, triggerType === 'subagent', aiSettings.fallback_model_id);
+              const fallback = await getProviderForUser(
+                userId,
+                userMessage,
+                triggerType === 'subagent',
+                aiSettings.fallback_model_id,
+                providerStatusConfig
+              );
               // Update local state for the retry
               const nextProvider = fallback.provider;
               const nextModel = fallback.model;

package/server/services/ai/models.js

@@ -192,7 +192,7 @@ async function refreshDynamicModels(baseUrl) {
     }
 }
 
-function createProviderInstance(providerStr, userId = null) {
+function createProviderInstance(providerStr, userId = null, configOverrides = {}) {
     const runtime = getProviderRuntimeConfig(userId, providerStr);
 
     if (!runtime.enabled) {
@@ -203,15 +203,15 @@ function createProviderInstance(providerStr, userId = null) {
     }
 
     if (providerStr === 'grok') {
-        return new GrokProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
+        return new GrokProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...configOverrides });
     } else if (providerStr === 'openai') {
-        return new OpenAIProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
+        return new OpenAIProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...configOverrides });
     } else if (providerStr === 'anthropic') {
-        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
+        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...configOverrides });
     } else if (providerStr === 'google') {
-        return new GoogleProvider({ apiKey: runtime.apiKey });
+        return new GoogleProvider({ apiKey: runtime.apiKey, ...configOverrides });
     } else if (providerStr === 'ollama') {
-        return new OllamaProvider({ baseUrl: runtime.baseUrl });
+        return new OllamaProvider({ baseUrl: runtime.baseUrl, ...configOverrides });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }

package/server/services/ai/providers/base.js

@@ -3,6 +3,7 @@ class BaseProvider {
     this.config = config;
     this.name = 'base';
     this.models = [];
+    this.onStatus = typeof config.onStatus === 'function' ? config.onStatus : null;
   }
 
   getDefaultModel() {

package/server/services/ai/providers/ollama.js

@@ -28,6 +28,13 @@ class OllamaProvider extends BaseProvider {
     if (found) return true;
 
     console.log(`[Ollama] Model '${model}' not found, pulling from registry...`);
+    this.onStatus?.({
+      kind: 'model_download',
+      status: 'started',
+      model,
+      phase: 'Downloading model',
+      message: `Downloading local Ollama model '${model}'. First-time pulls can take a while.`
+    });
     try {
       const res = await fetch(`${this.baseUrl}/api/pull`, {
         method: 'POST',
@@ -36,10 +43,24 @@ class OllamaProvider extends BaseProvider {
       });
       if (!res.ok) throw new Error(`Pull failed: ${res.statusText}`);
       console.log(`[Ollama] Model '${model}' pulled successfully.`);
+      this.onStatus?.({
+        kind: 'model_download',
+        status: 'completed',
+        model,
+        phase: 'Thinking',
+        message: `Local Ollama model '${model}' is ready.`
+      });
       // Refresh local model list
       await this.listModels();
       return true;
     } catch (e) {
+      this.onStatus?.({
+        kind: 'model_download',
+        status: 'failed',
+        model,
+        phase: 'Model download failed',
+        message: `Failed to download local Ollama model '${model}': ${e.message}`
+      });
       console.error(`[Ollama] Failed to pull model '${model}':`, e.message);
       throw e;
     }

package/server/services/android/controller.js

@@ -47,6 +47,18 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function tailFile(filePath, maxLines = 40) {
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8')
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    return lines.slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
 function commandExists(command) {
   const probe = spawnSync('bash', ['-lc', `command -v "${command}"`], { encoding: 'utf8' });
   return probe.status === 0;
@@ -103,6 +115,10 @@ function configuredSystemImagePlatform() {
   return String(process.env.ANDROID_SYSTEM_IMAGE_PLATFORM || '').trim() || null;
 }
 
+function shouldForceSdkRefresh() {
+  return String(process.env.ANDROID_FORCE_SDK_REFRESH || '').trim().toLowerCase() === 'true';
+}
+
 function systemImageArchCandidates() {
   const configured = parseCsvEnv(process.env.ANDROID_SYSTEM_IMAGE_ARCH);
   if (configured.length > 0) {
@@ -399,6 +415,7 @@ class AndroidController {
     this.cli = new CLIExecutor();
     this.avdName = readState().avdName || DEFAULT_AVD_NAME;
     this.bootstrapPromise = null;
+    this.startPromise = null;
     this.#registerProcessCleanup();
   }
 
@@ -465,7 +482,12 @@ class AndroidController {
   }
 
   async ensureBootstrapped() {
-    if (!(isExecutable(adbBinary()) && isExecutable(sdkManagerBinary()) && isExecutable(emulatorBinary()))) {
+    const binariesReady =
+      isExecutable(adbBinary()) &&
+      isExecutable(sdkManagerBinary()) &&
+      isExecutable(emulatorBinary());
+
+    if (!binariesReady) {
       if (this.bootstrapPromise) {
         await this.bootstrapPromise;
       } else {
@@ -478,16 +500,25 @@ class AndroidController {
       }
     }
 
+    const state = readState();
+    if (
+      state.bootstrapped === true &&
+      state.systemImage &&
+      !shouldForceSdkRefresh()
+    ) {
+      return;
+    }
+
     appendState({ bootstrapped: true });
     const sdkmanager = sdkManagerBinary();
     const available = await this.#run(`${quoteShell(sdkmanager)} --sdk_root=${quoteShell(SDK_ROOT)} --list`, { timeout: 300000 });
     const latestSystemImage = chooseConfiguredSystemImage(available) || chooseLatestSystemImage(available);
     if (!latestSystemImage) throw new Error(formatSystemImageError(available));
 
-    const state = readState();
-    const currentApiLevel = parseApiLevelFromSystemImage(state.systemImage);
+    const refreshedState = readState();
+    const currentApiLevel = parseApiLevelFromSystemImage(refreshedState.systemImage);
     const shouldUpgrade =
-      state.systemImage !== latestSystemImage.packageName ||
+      refreshedState.systemImage !== latestSystemImage.packageName ||
       currentApiLevel < latestSystemImage.apiLevel;
 
     if (shouldUpgrade) {
@@ -583,8 +614,13 @@ class AndroidController {
     fs.writeFileSync(configPath, content);
   }
 
-  async listDevices() {
-    await this.ensureBootstrapped();
+  async listDevices(options = {}) {
+    if (options.ensureBootstrapped !== false) {
+      await this.ensureBootstrapped();
+    }
+    if (!isExecutable(adbBinary())) {
+      return [];
+    }
     const out = await this.#run(`${quoteShell(adbBinary())} devices -l`);
     const lines = out.split('\n').map((line) => line.trim()).filter(Boolean);
     return lines
@@ -600,9 +636,9 @@ class AndroidController {
       });
   }
 
-  async getPrimarySerial() {
+  async getPrimarySerial(options = {}) {
     const state = readState();
-    const devices = await this.listDevices();
+    const devices = await this.listDevices(options);
     const preferred = state.serial ? devices.find((device) => device.serial === state.serial && device.status === 'device') : null;
     if (preferred) return preferred.serial;
     const emulator = devices.find((device) => device.emulator && device.status === 'device');
@@ -615,11 +651,30 @@ class AndroidController {
     return null;
   }
 
-  async startEmulator(options = {}) {
+  async #startEmulatorBlocking(options = {}) {
+    appendState({
+      starting: true,
+      startupPhase: 'Preparing Android runtime',
+      lastStartError: null,
+      startRequestedAt: readState().startRequestedAt || new Date().toISOString(),
+    });
+    console.log('[Android] Preparing emulator start');
     await this.ensureAvd();
+    appendState({
+      starting: true,
+      startupPhase: 'Checking for an existing Android device',
+      lastStartError: null,
+    });
     this.#normalizeAvdConfig();
     const serial = await this.getPrimarySerial();
     if (serial) {
+      appendState({
+        starting: false,
+        startupPhase: null,
+        serial,
+        lastStartError: null,
+        lastLogLine: 'Android device already running.',
+      });
       return {
         success: true,
         serial,
@@ -650,12 +705,59 @@ class AndroidController {
       stdio: ['ignore', out, out],
       env: sdkEnv(),
     });
+
+    console.log(`[Android] Emulator process started (pid ${child.pid})`);
+    appendState({
+      emulatorPid: child.pid,
+      avdName: this.avdName,
+      logPath,
+      starting: true,
+      startupPhase: 'Waiting for Android emulator to boot',
+      lastStartError: null,
+      lastLogLine: 'Android emulator process started. Waiting for boot completion...',
+    });
+
+    const processExit = new Promise((resolve) => {
+      child.once('exit', (code, signal) => {
+        resolve({ code, signal });
+      });
+      child.once('error', (error) => {
+        resolve({ code: null, signal: null, error });
+      });
+    });
+
     child.unref();
 
-    appendState({ emulatorPid: child.pid, avdName: this.avdName, logPath });
+    const bootResult = await Promise.race([
+      this.waitForDevice({ timeoutMs: options.timeoutMs || 240000 }).then((serial) => ({
+        serial,
+        exited: false,
+      })),
+      processExit.then((result) => ({
+        exited: true,
+        ...result,
+      })),
+    ]);
+
+    if (bootResult.exited) {
+      const recentLogLines = tailFile(logPath, 12);
+      const lastLine =
+        bootResult.error?.message ||
+        recentLogLines[recentLogLines.length - 1] ||
+        `Emulator process exited before boot completed (code ${bootResult.code ?? 'unknown'}, signal ${bootResult.signal ?? 'none'}).`;
+      throw new Error(lastLine);
+    }
 
-    const onlineSerial = await this.waitForDevice({ timeoutMs: options.timeoutMs || 240000 });
-    appendState({ serial: onlineSerial, emulatorPid: child.pid });
+    const onlineSerial = bootResult.serial;
+    appendState({
+      serial: onlineSerial,
+      emulatorPid: child.pid,
+      starting: false,
+      startupPhase: null,
+      lastStartError: null,
+      lastLogLine: 'Android emulator boot completed.',
+    });
+    console.log(`[Android] Emulator ready on ${onlineSerial}`);
 
     return {
       success: true,
@@ -665,6 +767,85 @@ class AndroidController {
     };
   }
 
+  async startEmulator(options = {}) {
+    if (this.startPromise) {
+      await this.startPromise;
+      const serial = await this.getPrimarySerial();
+      if (!serial) {
+        throw new Error(readState().lastStartError || 'Android emulator did not finish starting.');
+      }
+      return {
+        success: true,
+        serial,
+        reused: false,
+        bootstrapped: readState().bootstrapped === true,
+      };
+    }
+
+    return this.#startEmulatorBlocking(options);
+  }
+
+  async requestStartEmulator(options = {}) {
+    const serial = await this.getPrimarySerial({ ensureBootstrapped: false }).catch(() => null);
+    if (serial) {
+      appendState({
+        starting: false,
+        startupPhase: null,
+        serial,
+        lastStartError: null,
+        lastLogLine: 'Android device already running.',
+      });
+      return {
+        success: true,
+        pending: false,
+        serial,
+        reused: true,
+        bootstrapped: readState().bootstrapped === true,
+      };
+    }
+
+    if (!this.startPromise) {
+      const requestedAt = new Date().toISOString();
+      appendState({
+        starting: true,
+        startupPhase: 'Preparing Android runtime',
+        lastStartError: null,
+        startRequestedAt: requestedAt,
+        lastLogLine: 'Android start requested.',
+      });
+      const startPromise = this.#startEmulatorBlocking(options).catch((err) => {
+        const state = readState();
+        const recentLogLines = state.logPath ? tailFile(state.logPath, 12) : [];
+        const detailedMessage = recentLogLines[recentLogLines.length - 1] || err.message;
+        appendState({
+          starting: false,
+          startupPhase: 'Start failed',
+          lastStartError: detailedMessage,
+          lastLogLine: detailedMessage,
+        });
+        console.error('[Android] Emulator start failed:', detailedMessage);
+        throw new Error(detailedMessage);
+      }).finally(() => {
+        if (this.startPromise === startPromise) {
+          this.startPromise = null;
+        }
+      });
+      this.startPromise = startPromise;
+      startPromise.catch(() => {});
+    }
+
+    const state = readState();
+    return {
+      success: true,
+      pending: true,
+      bootstrapped: state.bootstrapped === true,
+      starting: true,
+      startupPhase: state.startupPhase || 'Preparing Android runtime',
+      startRequestedAt: state.startRequestedAt || null,
+      logPath: state.logPath || null,
+    };
+  }
+
   async waitForDevice(options = {}) {
     const timeoutMs = Math.max(10000, Number(options.timeoutMs) || 180000);
     const deadline = Date.now() + timeoutMs;
@@ -699,7 +880,14 @@ class AndroidController {
     if (state.emulatorPid) {
       try { process.kill(state.emulatorPid, 'SIGTERM'); } catch {}
     }
-    appendState({ serial: null, emulatorPid: null });
+    appendState({
+      serial: null,
+      emulatorPid: null,
+      starting: false,
+      startupPhase: null,
+      lastStartError: null,
+      lastLogLine: 'Android emulator stopped.',
+    });
 
     const deadline = Date.now() + 30000;
     while (Date.now() < deadline) {
@@ -980,24 +1168,39 @@ class AndroidController {
   }
 
   async getStatus() {
-    const devices = isExecutable(adbBinary()) ? await this.listDevices().catch(() => []) : [];
+    const devices = isExecutable(adbBinary())
+      ? await this.listDevices({ ensureBootstrapped: false }).catch(() => [])
+      : [];
     const state = readState();
-    let lastLogLine = null;
+    let lastLogLine =
+      state.lastStartError ||
+      state.lastLogLine ||
+      state.startupPhase ||
+      null;
     if (state.logPath && fs.existsSync(state.logPath)) {
       try {
         const lines = fs.readFileSync(state.logPath, 'utf8')
           .split('\n')
           .map((line) => line.trim())
           .filter(Boolean);
-        lastLogLine = [...lines].reverse().find((line) =>
+        const emulatorLogLine = [...lines].reverse().find((line) =>
           /fatal|error|warning|boot completed|disk space|running avd/i.test(line)
         ) || lines[lines.length - 1] || null;
+        lastLogLine = emulatorLogLine || lastLogLine;
       } catch {
-        lastLogLine = null;
+        lastLogLine =
+          state.lastStartError ||
+          state.lastLogLine ||
+          state.startupPhase ||
+          null;
       }
     }
     return {
       bootstrapped: state.bootstrapped === true,
+      starting: state.starting === true || this.startPromise != null,
+      startupPhase: state.startupPhase || null,
+      startRequestedAt: state.startRequestedAt || null,
+      lastStartError: state.lastStartError || null,
       sdkRoot: SDK_ROOT,
       avdHome: AVD_HOME,
       avdName: this.avdName,