Merge pull request #726 from nexu-io/merge/release-v0.1.8-to-main

chore: merge release/v0.1.8 back to main

Author: mrcfps

.github/workflows/desktop-e2e.yml

@@ -140,3 +140,86 @@ jobs:
             e2e/desktop/captures/
           if-no-files-found: warn
           retention-days: 14
+
+      - name: Notify Feishu E2E result
+        if: always()
+        env:
+          FEISHU_WEBHOOK: ${{ secrets.NIGHTLY_FEISHU_WEBHOOK }}
+          E2E_MODE: ${{ github.event.inputs.mode || 'model' }}
+          E2E_SOURCE: ${{ github.event.inputs.source || 'download' }}
+          E2E_CHANNEL: ${{ github.event.inputs.channel || 'nightly' }}
+          E2E_STATUS: ${{ job.status }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [ -z "$FEISHU_WEBHOOK" ]; then
+            echo "No Feishu webhook, skipping"
+            exit 0
+          fi
+
+          run_url="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+          short_sha="${GITHUB_SHA::7}"
+          branch="${GITHUB_HEAD_REF:-${GITHUB_REF_NAME}}"
+          trigger="${GITHUB_TRIGGERING_ACTOR:-unknown}"
+
+          if [ "$E2E_STATUS" = "success" ]; then
+            template="green"
+            title="✅ Desktop E2E 测试通过"
+          else
+            template="red"
+            title="❌ Desktop E2E 测试失败"
+          fi
+
+          # Determine what triggered this: PR, commit, or scheduled
+          trigger_info=""
+          if [ -n "$GITHUB_HEAD_REF" ]; then
+            pr_number=$(echo "$GITHUB_REF" | grep -oE '[0-9]+' || echo "")
+            trigger_info="PR [#${pr_number}](https://github.com/${{ github.repository }}/pull/${pr_number}) on \`${branch}\`"
+          elif [ "${{ github.event_name }}" = "schedule" ]; then
+            trigger_info="定时触发 (\`${branch}\` @ \`${short_sha}\`)"
+          else
+            trigger_info="手动触发 (\`${branch}\` @ \`${short_sha}\`)"
+          fi
+
+          card=$(jq -n \
+            --arg title "$title" \
+            --arg template "$template" \
+            --arg mode "$E2E_MODE" \
+            --arg source "$E2E_SOURCE" \
+            --arg channel "$E2E_CHANNEL" \
+            --arg trigger_info "$trigger_info" \
+            --arg trigger "$trigger" \
+            --arg run_url "$run_url" \
+            '{
+              msg_type: "interactive",
+              card: {
+                header: {
+                  template: $template,
+                  title: {
+                    tag: "plain_text",
+                    content: $title
+                  }
+                },
+                elements: [
+                  {
+                    tag: "markdown",
+                    content: ("**触发来源**\n" + $trigger_info + "\n触发人: " + $trigger + "\n\n**测试配置**\n- 模式: `" + $mode + "`\n- 构建来源: `" + $source + "`\n- 频道: `" + $channel + "`")
+                  },
+                  {
+                    tag: "action",
+                    actions: [
+                      {
+                        tag: "button",
+                        text: { tag: "plain_text", content: "📋 查看详情" },
+                        type: "default",
+                        url: $run_url
+                      }
+                    ]
+                  }
+                ]
+              }
+            }')
+
+          curl -sf -X POST "$FEISHU_WEBHOOK" \
+            -H "Content-Type: application/json" \
+            -d "$card" || echo "Feishu notification failed (non-fatal)"

apps/desktop/main/index.ts

@@ -683,6 +683,7 @@ async function runLaunchdColdStart(): Promise<void> {
     skillNodePath,
     openclawTmpDir,
     proxyEnv,
+    log: (message: string) => logColdStart(message),
     appVersion: app.getVersion(),
     userDataPath: app.getPath("userData"),
     buildSource:

apps/desktop/main/services/launchd-bootstrap.ts

@@ -11,7 +11,7 @@
 import { execFile } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import * as fs from "node:fs/promises";
-import { createConnection } from "node:net";
+import net, { createConnection } from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
@@ -83,6 +83,8 @@ export interface LaunchdBootstrapEnv {
   openclawTmpDir: string;
   /** Normalized proxy env propagated to controller/openclaw launchd services */
   proxyEnv: Record<string, string>;
+  /** Optional structured logger for packaged mode (console.log is lost in packaged builds) */
+  log?: (message: string) => void;
 }
 
 export interface LaunchdBootstrapResult {
@@ -278,20 +280,28 @@ function isProcessAlive(pid: number): boolean {
 // Port occupier detection
 // ---------------------------------------------------------------------------
 
+/**
+ * Check if a port is occupied by attempting to bind a temporary server.
+ * Returns `{ pid: 0 }` if occupied, `null` if free.
+ *
+ * Uses net.createServer().listen() instead of lsof or net.connect because:
+ * - lsof is blocked by macOS hardened runtime in packaged Electron apps
+ * - net.connect conflicts with probePort (both use createConnection)
+ */
 async function detectPortOccupier(
   port: number,
 ): Promise<{ pid: number } | null> {
-  try {
-    const { stdout } = await execFileAsync("lsof", [
-      `-iTCP:${port}`,
-      "-sTCP:LISTEN",
-      "-t",
-    ]);
-    const pid = Number.parseInt(stdout.trim(), 10);
-    return Number.isNaN(pid) ? null : { pid };
-  } catch {
-    return null;
-  }
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      // EADDRINUSE or other bind failure — port is occupied
+      resolve({ pid: 0 });
+    });
+    server.listen(port, "127.0.0.1", () => {
+      // Successfully bound — port is free. Close immediately.
+      server.close(() => resolve(null));
+    });
+  });
 }
 
 /**
@@ -374,6 +384,7 @@ async function cleanupStalePlists(
 export async function bootstrapWithLaunchd(
   env: LaunchdBootstrapEnv,
 ): Promise<LaunchdBootstrapResult> {
+  const log = env.log ?? console.log;
   const logDir = await ensureLogDir(env.nexuHome);
   const plistDir = env.plistDir ?? getDefaultPlistDir(env.isDev);
 
@@ -617,7 +628,23 @@ export async function bootstrapWithLaunchd(
   }
 
   if (openclawRunning && useRecoveredPorts) {
-    openclawHealthy = await probePort(effectivePorts.openclawPort);
+    const portListening = await probePort(effectivePorts.openclawPort);
+    // Port listening isn't enough — verify it's OUR openclaw by checking
+    // that the launchd service env matches our expected token/state dir.
+    // This prevents attaching to a global openclaw or ClawX on the same port.
+    if (portListening) {
+      const ocEnv = (await launchd.getServiceStatus(labels.openclaw)).env;
+      const expectedToken = env.gatewayToken;
+      const runningToken = ocEnv?.OPENCLAW_GATEWAY_TOKEN;
+      if (expectedToken && runningToken && runningToken !== expectedToken) {
+        console.log(
+          "OpenClaw port is listening but gateway token mismatch — not our instance",
+        );
+        openclawHealthy = false;
+      } else {
+        openclawHealthy = true;
+      }
+    }
     if (openclawHealthy) {
       console.log("OpenClaw already running and healthy");
     } else {
@@ -644,12 +671,20 @@ export async function bootstrapWithLaunchd(
     }
   }
   if (!openclawHealthy) {
+    const preOccupier = await detectPortOccupier(effectivePorts.openclawPort);
+    log(
+      `[bootstrap] pre-findFreePort: openclawPort=${effectivePorts.openclawPort} occupier=${preOccupier ? `PID ${preOccupier.pid}` : "none"}`,
+    );
     const freePort = await findFreePort(effectivePorts.openclawPort);
     if (freePort !== effectivePorts.openclawPort) {
       console.log(
         `OpenClaw port ${effectivePorts.openclawPort} occupied, using ${freePort}`,
       );
       effectivePorts.openclawPort = freePort;
+    } else {
+      log(
+        `[bootstrap] openclawPort ${effectivePorts.openclawPort} appears free, keeping`,
+      );
     }
   }
 
@@ -697,6 +732,66 @@ export async function bootstrapWithLaunchd(
   if (!openclawHealthy) {
     await ensureService(labels.openclaw, "openclaw");
     await ensureRunning(labels.openclaw, "openclaw");
+
+    // Verify our openclaw actually owns the port. Another launchd service
+    // (e.g. global `ai.openclaw.gateway` with KeepAlive=true) may have
+    // raced us and grabbed the port first. If so, pick a new port and
+    // re-bootstrap our service.
+    // Wait briefly for the port to be bound (our openclaw needs time to start).
+    await new Promise((r) => setTimeout(r, 2000));
+    const occupier = await detectPortOccupier(effectivePorts.openclawPort);
+    const ocStatus = await launchd.getServiceStatus(labels.openclaw);
+    log(
+      `[bootstrap] post-launch check: port=${effectivePorts.openclawPort} occupied=${!!occupier} ocStatus=${JSON.stringify({ pid: ocStatus.pid, status: ocStatus.status })}`,
+    );
+    // Port is stolen if someone is listening but our service crashed or
+    // isn't running. We can't compare PIDs (lsof blocked by hardened
+    // runtime), so check if our service is healthy instead.
+    const portStolen =
+      occupier && (ocStatus.pid == null || ocStatus.status !== "running");
+    log(`[bootstrap] portStolen=${portStolen}`);
+    if (portStolen) {
+      log(
+        `[bootstrap] OpenClaw port ${effectivePorts.openclawPort} stolen by PID ${occupier.pid} (ours is ${ocStatus.pid}), reassigning`,
+      );
+      // Bootout crashed openclaw and wait for launchd to fully release it.
+      // Use bootoutAndWaitForExit which captures the PID before bootout
+      // so waitForExit can SIGKILL if needed (plain waitForExit without
+      // knownPid exits early on "unknown" status).
+      await launchd
+        .bootoutAndWaitForExit(labels.openclaw, 5000)
+        .catch(() => {});
+
+      const newPort = await findFreePort(effectivePorts.openclawPort + 1);
+      effectivePorts.openclawPort = newPort;
+
+      // Regenerate plists with new port for both openclaw and controller
+      const retryPlistEnv: PlistEnv = {
+        ...plistEnv,
+        openclawPort: newPort,
+      };
+
+      // Re-bootstrap openclaw on new port
+      const retryPlist = generatePlist("openclaw", retryPlistEnv);
+      await launchd.installService(labels.openclaw, retryPlist);
+      await launchd.startService(labels.openclaw);
+      await ensureRunning(labels.openclaw, "openclaw");
+
+      // Controller needs the new port — re-bootstrap it too
+      await launchd
+        .bootoutAndWaitForExit(labels.controller, 5000)
+        .catch(() => {});
+      const retryControllerPlist = generatePlist("controller", retryPlistEnv);
+      await launchd.installService(labels.controller, retryControllerPlist);
+      await launchd.startService(labels.controller);
+      await ensureRunning(labels.controller, "controller");
+      // Controller was restarted — must wait for readiness again even if
+      // it was previously healthy (attach path sets needsControllerReady=false).
+      needsControllerReady = true;
+      log(
+        `[bootstrap] OpenClaw reassigned to port ${newPort}, controller restarted`,
+      );
+    }
   } else {
     console.log("[bootstrap] openclaw already healthy, skipping");
   }

apps/desktop/main/services/plist-generator.ts

@@ -229,7 +229,9 @@ function generateOpenclawPlist(label: string, env: PlistEnv): string {
         <string>${escapeXml(env.nodePath)}</string>
         <string>${escapeXml(env.openclawPath)}</string>
         <string>gateway</string>
-        <string>run</string>${authArgs}
+        <string>run</string>
+        <string>--port</string>
+        <string>${env.openclawPort}</string>${authArgs}
     </array>
 
     <key>WorkingDirectory</key>
@@ -250,7 +252,13 @@ function generateOpenclawPlist(label: string, env: PlistEnv): string {
         <key>OPENCLAW_SERVICE_MARKER</key>
         <string>launchd</string>
         <key>OPENCLAW_IMAGE_BACKEND</key>
-        <string>sips</string>
+        <string>sips</string>${
+          env.gatewayToken
+            ? `
+        <key>OPENCLAW_GATEWAY_TOKEN</key>
+        <string>${escapeXml(env.gatewayToken)}</string>`
+            : ""
+        }
         <key>HOME</key>
         <string>${escapeXml(os.homedir())}</string>${renderProxyEnvEntries(
           env.proxyEnv,

e2e/desktop/README.md

@@ -129,7 +129,9 @@ NEXU_DESKTOP_E2E_SKIP_CODESIGN=true npm run test:model
 |----------|------------------|-------------------|
 | **Crash Recovery** | `kill -9` the Electron main process (Force Quit simulation) | launchd services survive; app attaches or rebuilds on restart |
 | **Orphan Cleanup** | Kill Electron, leave controller/openclaw as orphan processes | App detects and cleans up orphans on restart, starts fresh |
-| **Port Conflict** | Occupy port 50800 with a dummy listener before launching | App detects EADDRINUSE, picks an alternative port or exits gracefully |
+| **Port Conflict (Controller)** | Occupy port 50800 with a dummy listener before launching | App detects EADDRINUSE, picks an alternative port or exits gracefully |
+| **Port Conflict (OpenClaw)** | Occupy port 18789 (simulating global `openclaw install` or ClawX) | App detects conflict, auto-assigns alternative port (18790+), coexists without killing the other service |
+| **Port Theft (OpenClaw)** | Start normally, kill openclaw, occupy its port, re-launch | App detects port was stolen on cold start, reassigns to new port, recovers |
 | **Stale State** | Write a fake `runtime-ports.json` pointing to non-existent services | App detects stale session, ignores fake state, performs fresh start |
 | **Double Launch** | Start a second instance while the app is already running | Second instance exits (single-instance lock), first instance unaffected |