merge: sync upstream v0.1.15 (PR ValueCell-ai#119 gemini apikey fix, PR ValueCell-ai#120 gateway start waiting) and bump version to 0.1.16

Author: peiban666

electron/gateway/manager.ts

@@ -229,23 +229,26 @@ export class GatewayManager extends EventEmitter {
     this.setStatus({ state: 'starting', reconnectAttempts: 0 });
 
     try {
-      // Check if Python environment is ready (self-healing)
-      const pythonReady = await isPythonReady();
-      if (!pythonReady) {
-        logger.info('Python environment missing or incomplete, attempting background repair...');
-        // We don't await this to avoid blocking Gateway startup, 
-        // as uv run will handle it if needed, but this pre-warms it.
-        void setupManagedPython().catch(err => {
-          logger.error('Background Python repair failed:', err);
-        });
-      }
+      // Check if Python environment is ready (self-healing) asynchronously
+      void isPythonReady().then(pythonReady => {
+        if (!pythonReady) {
+          logger.info('Python environment missing or incomplete, attempting background repair...');
+          // We don't await this to avoid blocking Gateway startup, 
+          // as uv run will handle it if needed, but this pre-warms it.
+          void setupManagedPython().catch(err => {
+            logger.error('Background Python repair failed:', err);
+          });
+        }
+      }).catch(err => {
+        logger.error('Failed to check Python environment:', err);
+      });
 
       // Check if Gateway is already running
       logger.debug('Checking for existing Gateway...');
       const existing = await this.findExistingGateway();
       if (existing) {
         logger.debug(`Found existing Gateway on port ${existing.port}`);
-        await this.connect(existing.port);
+        await this.connect(existing.port, existing.externalToken);
         this.ownsProcess = false;
         this.setStatus({ pid: undefined });
         this.startHealthCheck();
@@ -318,33 +321,39 @@ export class GatewayManager extends EventEmitter {
     // Kill process and wait for it to actually exit (so the port is released)
     if (this.process && this.ownsProcess) {
       const child = this.process;
-      this.process = null;
-      logger.info(`Sending SIGTERM to Gateway (pid=${child.pid ?? 'unknown'})`);
-      child.kill('SIGTERM');
-
-      // Wait for the process to exit, with a SIGKILL fallback
+      
       await new Promise<void>((resolve) => {
-        const killTimer = setTimeout(() => {
+        // If process already exited, resolve immediately
+        if (child.exitCode !== null || child.signalCode !== null) {
+          return resolve();
+        }
+        
+        logger.info(`Sending SIGTERM to Gateway (pid=${child.pid ?? 'unknown'})`);
+        child.kill('SIGTERM');
+        
+        // Force kill after timeout
+        const timeout = setTimeout(() => {
           if (child.exitCode === null && child.signalCode === null) {
             logger.warn(`Gateway did not exit in time, sending SIGKILL (pid=${child.pid ?? 'unknown'})`);
-            try { child.kill('SIGKILL'); } catch { /* already dead */ }
+            child.kill('SIGKILL');
           }
-        }, 3000);
-
-        const done = () => {
-          clearTimeout(killTimer);
           resolve();
-        };
+        }, 5000);
 
-        // If the process already exited before we got here
-        if (child.exitCode !== null || child.signalCode !== null) {
-          done();
-          return;
-        }
-        child.once('exit', done);
-        // Safety cap: resolve after 6s even if exit event never fires
-        setTimeout(done, 6000);
+        child.once('exit', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        
+        child.once('error', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
       });
+      
+      if (this.process === child) {
+        this.process = null;
+      }
     }
     this.ownsProcess = false;
 
@@ -364,18 +373,6 @@ export class GatewayManager extends EventEmitter {
   async restart(): Promise<void> {
     logger.debug('Gateway restart requested');
     await this.stop();
-    // Wait for any in-flight start() to finish unwinding after abort
-    const maxWait = 10;
-    for (let i = 0; i < maxWait && this.startLock; i++) {
-      await new Promise(resolve => setTimeout(resolve, 500));
-    }
-    if (this.startLock) {
-      logger.warn('Gateway restart: startLock still held after waiting, forcing release');
-      this.startLock = false;
-      this.startAbort = null;
-    }
-    // Brief delay before restart
-    await new Promise(resolve => setTimeout(resolve, 500));
     await this.start();
   }
 
@@ -487,11 +484,46 @@ export class GatewayManager extends EventEmitter {
   /**
    * Find existing Gateway process by attempting a WebSocket connection
    */
-  private async findExistingGateway(): Promise<{ port: number } | null> {
+  private async findExistingGateway(): Promise<{ port: number, externalToken?: string } | null> {
     try {
       const port = PORTS.OPENCLAW_GATEWAY;
+      
+      try {
+        const { stdout } = await new Promise<{ stdout: string }>((resolve) => {
+          import('child_process').then(cp => {
+            cp.exec(`lsof -i :${port} | grep LISTEN`, (err, stdout) => {
+              if (err) resolve({ stdout: '' });
+              else resolve({ stdout });
+            });
+          });
+        });
+        
+        if (stdout.trim()) {
+          // A process is listening on the port
+          const pids = stdout.split('\n')
+            .map(line => line.trim().split(/\s+/)[1])
+            .filter(pid => pid && pid !== 'PID');
+            
+          if (pids.length > 0) {
+            // Try to kill it if it's not us to avoid connection issues
+            // This happens frequently on HMR / dev reloads
+            if (!this.process || !pids.includes(String(this.process.pid))) {
+               logger.info(`Found orphaned process listening on port ${port} (PID: ${pids[0]}), attempting to kill...`);
+               for (const pid of pids) {
+                 try { process.kill(parseInt(pid), 'SIGKILL'); } catch { /* ignore */ }
+               }
+               // Wait a moment for port to be released
+               await new Promise(r => setTimeout(r, 500));
+               return null; // Return null so we start a fresh instance
+            }
+          }
+        }
+      } catch (err) {
+        logger.debug('Error checking for existing process on port:', err);
+      }
+
       // Try a quick WebSocket connection to check if gateway is listening
-      return await new Promise<{ port: number } | null>((resolve) => {
+      return await new Promise<{ port: number, externalToken?: string } | null>((resolve) => {
         const testWs = new WebSocket(`ws://localhost:${port}/ws`);
         const timeout = setTimeout(() => {
           testWs.close();
@@ -717,8 +749,10 @@ export class GatewayManager extends EventEmitter {
   /**
    * Wait for Gateway to be ready by checking if the port is accepting connections
    */
-  private async waitForReady(retries = 600, interval = 1000): Promise<void> {
+  private async waitForReady(retries = 2400, interval = 250): Promise<void> {
+    const child = this.process;
     for (let i = 0; i < retries; i++) {
+<<<<<<< HEAD
       // Abort if stop() was called while we are still waiting
       if (this.startAbort?.signal.aborted) {
         logger.info('waitForReady aborted by stop request');
@@ -733,6 +767,12 @@ export class GatewayManager extends EventEmitter {
       if (this.process.exitCode !== null || this.process.signalCode !== null) {
         const code = this.process.exitCode;
         const signal = this.process.signalCode;
+=======
+      // Early exit if the gateway process has already exited
+      if (child && (child.exitCode !== null || child.signalCode !== null)) {
+        const code = child.exitCode;
+        const signal = child.signalCode;
+>>>>>>> upstream/main
         logger.error(`Gateway process exited before ready (${this.formatExit(code, signal)})`);
         throw new Error(`Gateway process exited before becoming ready (${this.formatExit(code, signal)})`);
       }
@@ -779,9 +819,7 @@ export class GatewayManager extends EventEmitter {
   /**
    * Connect WebSocket to Gateway
    */
-  private async connect(port: number): Promise<void> {
-    // Get token for WebSocket authentication
-    const gatewayToken = await getSetting('gatewayToken');
+  private async connect(port: number, _externalToken?: string): Promise<void> {
     logger.debug(`Connecting Gateway WebSocket (ws://localhost:${port}/ws)`);
 
     return new Promise((resolve, reject) => {
@@ -826,6 +864,9 @@ export class GatewayManager extends EventEmitter {
       this.ws.on('open', async () => {
         logger.debug('Gateway WebSocket opened, sending connect handshake');
 
+        // Re-fetch token here before generating payload just in case it updated while connecting
+        const currentToken = await getSetting('gatewayToken');
+        
         // Send proper connect handshake as required by OpenClaw Gateway protocol
         // The Gateway expects: { type: "req", id: "...", method: "connect", params: ConnectParams }
         // Since 2026.2.15, scopes are only granted when a signed device identity is included.
@@ -838,14 +879,15 @@ export class GatewayManager extends EventEmitter {
 
         const device = (() => {
           if (!this.deviceIdentity) return undefined;
+          
           const payload = buildDeviceAuthPayload({
             deviceId: this.deviceIdentity.deviceId,
             clientId,
             clientMode,
             role,
             scopes,
             signedAtMs,
-            token: gatewayToken ?? null,
+            token: currentToken ?? null,
           });
           const signature = signDevicePayload(this.deviceIdentity.privateKeyPem, payload);
           return {
@@ -871,7 +913,7 @@ export class GatewayManager extends EventEmitter {
               mode: clientMode,
             },
             auth: {
-              token: gatewayToken,
+              token: currentToken,
             },
             caps: [],
             role,
@@ -1113,7 +1155,7 @@ export class GatewayManager extends EventEmitter {
         // Try to find existing Gateway first
         const existing = await this.findExistingGateway();
         if (existing) {
-          await this.connect(existing.port);
+          await this.connect(existing.port, existing.externalToken);
           this.ownsProcess = false;
           this.setStatus({ pid: undefined });
           this.reconnectAttempts = 0;

electron/main/ipc-handlers.ts

@@ -66,7 +66,7 @@ export function registerIpcHandlers(
   registerOpenClawHandlers();
 
   // Provider handlers
-  registerProviderHandlers();
+  registerProviderHandlers(gatewayManager);
 
   // Shell handlers
   registerShellHandlers();
@@ -794,7 +794,7 @@ function registerWhatsAppHandlers(mainWindow: BrowserWindow): void {
 /**
  * Provider-related IPC handlers
  */
-function registerProviderHandlers(): void {
+function registerProviderHandlers(gatewayManager: GatewayManager): void {
   // Get all providers with key info
   ipcMain.handle('provider:list', async () => {
     return await getAllProvidersWithKeyInfo();
@@ -1009,6 +1009,7 @@ function registerProviderHandlers(): void {
           if (providerKey) {
             saveProviderKeyToOpenClaw(provider.type, providerKey);
           }
+
         } catch (err) {
           console.warn('Failed to set OpenClaw default model:', err);
         }
@@ -1288,12 +1289,8 @@ async function validateGoogleQueryKey(
   apiKey: string,
   baseUrl?: string
 ): Promise<{ valid: boolean; error?: string }> {
-  const trimmedBaseUrl = baseUrl?.trim();
-  if (!trimmedBaseUrl) {
-    return { valid: false, error: `Base URL is required for provider "${providerType}" validation` };
-  }
-
-  const base = normalizeBaseUrl(trimmedBaseUrl);
+  // Default to the official Google Gemini API base URL if none is provided
+  const base = normalizeBaseUrl(baseUrl || 'https://generativelanguage.googleapis.com/v1beta');
   const url = `${base}/models?pageSize=1&key=${encodeURIComponent(apiKey)}`;
   return await performProviderValidationRequest(providerType, url, {});
 }

electron/utils/channel-config.ts

@@ -172,6 +172,24 @@ export function saveChannelConfig(
         }
     }
 
+    // Special handling for Feishu: default to open DM policy with wildcard allowlist
+    if (channelType === 'feishu') {
+        const existingConfig = currentConfig.channels[channelType] || {};
+        transformedConfig.dmPolicy = transformedConfig.dmPolicy ?? existingConfig.dmPolicy ?? 'open';
+        
+        let allowFrom = transformedConfig.allowFrom ?? existingConfig.allowFrom ?? ['*'];
+        if (!Array.isArray(allowFrom)) {
+            allowFrom = [allowFrom];
+        }
+        
+        // If dmPolicy is open, OpenClaw schema requires '*' in allowFrom
+        if (transformedConfig.dmPolicy === 'open' && !allowFrom.includes('*')) {
+            allowFrom = [...allowFrom, '*'];
+        }
+        
+        transformedConfig.allowFrom = allowFrom;
+    }
+
     // Merge with existing config
     currentConfig.channels[channelType] = {
         ...currentConfig.channels[channelType],

electron/utils/openclaw-auth.ts

@@ -229,8 +229,8 @@ export function setOpenClawDefaultModel(provider: string, modelOverride?: string
   config.agents = agents;
 
   // Configure models.providers for providers that need explicit registration.
-  // For built-in providers this comes from registry; for custom/ollama-like
-  // providers callers can supply runtime overrides.
+  // Built-in providers (anthropic, google) are part of OpenClaw's pi-ai catalog
+  // and must NOT have a models.providers entry — it would override the built-in.
   const providerCfg = getProviderConfig(provider);
   if (providerCfg) {
     const models = (config.models || {}) as Record<string, unknown>;
@@ -246,7 +246,6 @@ export function setOpenClawDefaultModel(provider: string, modelOverride?: string
       : [];
     const registryModels = (providerCfg.models ?? []).map((m) => ({ ...m })) as Array<Record<string, unknown>>;
 
-    // Merge model entries by id and ensure the selected/default model id exists.
     const mergedModels = [...registryModels];
     for (const item of existingModels) {
       const id = typeof item?.id === 'string' ? item.id : '';
@@ -262,13 +261,25 @@ export function setOpenClawDefaultModel(provider: string, modelOverride?: string
       ...existingProvider,
       baseUrl: providerCfg.baseUrl,
       api: providerCfg.api,
-      apiKey: providerCfg.apiKeyEnv,
+      apiKey: `\${${providerCfg.apiKeyEnv}}`,
       models: mergedModels,
     };
     console.log(`Configured models.providers.${provider} with baseUrl=${providerCfg.baseUrl}, model=${modelId}`);
 
     models.providers = providers;
     config.models = models;
+  } else {
+    // Built-in provider: remove any stale models.providers entry that may
+    // have been written by an earlier version. Leaving it in place would
+    // override the native pi-ai catalog and can break streaming/auth.
+    const models = (config.models || {}) as Record<string, unknown>;
+    const providers = (models.providers || {}) as Record<string, unknown>;
+    if (providers[provider]) {
+      delete providers[provider];
+      console.log(`Removed stale models.providers.${provider} (built-in provider)`);
+      models.providers = providers;
+      config.models = models;
+    }
   }
 
   // Ensure gateway mode is set
@@ -355,7 +366,7 @@ export function setOpenClawDefaultModelWithOverride(
       models: freshModels,
     };
     if (override.apiKeyEnv) {
-      nextProvider.apiKey = override.apiKeyEnv;
+      nextProvider.apiKey = `\${${override.apiKeyEnv}}`;
     }
 
     providers[provider] = nextProvider;

electron/utils/provider-registry.ts

@@ -53,11 +53,8 @@ const REGISTRY: Record<string, ProviderBackendMeta> = {
   google: {
     envVar: 'GEMINI_API_KEY',
     defaultModel: 'google/gemini-3-pro-preview',
-    providerConfig: {
-      baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
-      api: 'google',
-      apiKeyEnv: 'GEMINI_API_KEY',
-    },
+    // google is built-in to OpenClaw's pi-ai catalog, no providerConfig needed.
+    // Adding models.providers.google overrides the built-in and can break Gemini.
   },
   openrouter: {
     envVar: 'OPENROUTER_API_KEY',

package.json

@@ -1,6 +1,6 @@
 {
     "name": "clawx",
-    "version": "0.1.15",
+    "version": "0.1.16",
     "pnpm": {
         "onlyBuiltDependencies": [
             "@whiskeysockets/baileys",